目錄

• C語言實現順序棧和OOP實現順序棧
  • 1,順序棧
  • 2，C語言實現順序棧
  • 3,用OOP實現一個順序棧

C語言實現順序棧和OOP實現順序棧

1,順序棧

（1）定義：棧（stack）又名堆疊，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，它是把棧頂元素刪除掉，使其相鄰的元素成為新的棧頂元素。

（2）棧作為一種資料結構，是一種只能在一端進行插入和刪除操作的特殊線性表，它按照先進後出的原則儲存資料，先進入的資料被壓入棧底，最後的資料在棧頂，需要讀資料的時候從棧頂開始彈出資料（最後一個數據被第一個讀出來）。棧具有記憶作用，對棧的插入與刪除操作中，不需要改變棧底指標。

（3）圖解：

2，C語言實現順序棧

#include<stdio.h>
#include<assert.h>
#define STACK_LEN 5
typedef struct Sqstack
{
    int elem[STACK_LEN];
    int top;//當前可存放資料的下標
}Sqstack,*Pstack;
void InitStack(Pstack ps)
{
    assert(ps!=NULL);
    ps->top=0;
}
bool Push(Pstack ps,int val)//壓棧
{
    assert(ps!=NULL);
    if(Isfull(ps))
    {
        return false;
    }
    ps->elem[ps->top++]=val;
    return true;
}
bool Pop(Pstack ps,int *rtv)//刪除、出棧
{
    assert(ps!=NULL);
    if(IsEmpty(ps))
    {
         return false;       
    }
    if(rtv!=NULL)
    {
        ps->top--;
        *rtv=ps->elem[ps->top];
    }
}
bool GetTop(Pstack ps,int *rtv)//得到棧頂元素， 但是不刪除
{
    assert(ps!=NULL);
    if(IsEmpty(ps))
    {
        return false;
    }
    if(rtv!=NULL)
    {
        *rtv=ps->elem[ps->top-1];
    }
}
bool IsEmpty(Pstack ps)//判空
{
    assert(ps!=NULL);
    return ps->top==0;
}
bool Isfull(Pstack ps)//判滿
{
    assert(ps!=NULL);
    return ps->top==STACK_LEN;
}
void Clear(Pstack ps)//top 指標的操作
{
    ps->top=0;
}
void Destroy(Pstack ps);//這裡沒有動態記憶體分配
{
    Clear(ps);
}
void Show(Pstack ps)
{
    for(int i=0;i<ps->top;i++)
    {
        printf("%d ",ps->elem[i]);
    }
    printf("\n");
}
 

3,用OOP實現一個順序棧

#include<iostream>
using namespace std;

class CStack
{
 public:
    CStack()        //預設建構函式
    {
        mtop=0;
        msize=10;
        mStack=new int[msize];
    }
    /*CStack(int size=10)   //帶引數的建構函式
    {
        mtop=0;
        msize=size;
        mStack=new int[msize];
    }*/
    
    ~CStack()                        //析構
    {
        delete[]mStack;
        mStack=NULL;
    }
    
     void push(int val)                 //入棧
     {
         if(full())
         {
             resize();
         }
         mStack[mtop++]=val;
     }
    
    void pop()                     //出棧
    {
        if(empty())
        {
            return ;
        }
        mtop--;
    }
    
    int top()                      //獲取棧頂元素
    { 
       return mStack[mtop-1]; 
    }
    
    bool full()              //判滿
    {
        return mtop==msize;
    }
    bool empty()              //判空
    {
        return mtop==0;
    }
  private:
    int*mStack;
    int mtop;
    int msize;
    void resize()                //二倍擴容
    {
        int *mtmp=new int[msize*2];
        for(int i=0;i<msize;i++)
        {
            mtemp[i]=mStack[i];
        }
        delete[]mStack;
        mStack=mtmp;
        msize*=2;
    }
};