棧的概念：

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

順序棧：

base.h

這個標頭檔案主要用來存放公用的常量和型別。

//base.h
//-----公用的常量和型別----------
#include<iostream>
#include<stdlib.h>
#include<time.h>
 

using namespace std;
#include<malloc.h>
#include<string.h>

//函式結果狀態程式碼
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //不可行的 infeaslble
#define OVERFLOW -2

typedef int Status;
typedef int SElemType;

sq_Stack.h

sq_Stack.h標頭檔案用來具體實體實現棧的基本操作。

//sq_stack.h  順序棧
 


//-------------棧的順序儲存表示----------------

#define STACK_INIT_SIZE 100 //儲存空間初始分配量
#define STACKINCREMENT 10 //儲存空間分配增量

typedef struct{
    SElemType *base; //在棧構造之前和銷燬之後，base的值為NULL
    SElemType *top; //棧頂指標
    int stacksize;  //當前分配的儲存空間，以元素為單位
}SqStack;

//----基本操作的函式原型說明-----------

//構建一個空棧S
Status InitStack_Sq(SqStack &S){
    S.base
 
 = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if(!S.base)  //判斷是否空間分配成功
        exit(OVERFLOW);
    S.top = S.base; //棧頂與棧底指向同一個位置
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}//InitStack_Sq

//銷燬棧S
Status DestroyStack_Sq(SqStack &S){
    if(S.base){
        free(S.base);
        S.top = S.base = NULL;
        S.stacksize = 0;
        cout<<"棧銷燬成功！"<<endl;
        return OK;
    }else{
        cout<<"棧不存在,不需要銷燬！"<<endl;
        return ERROR;
    }
}//DestroyStack_Sq

//初始條件：棧S存在
//操作結果：清空棧
Status CleanStack_Sq(SqStack &S){
    S.top = S.base;
    return OK;
}//CleanStack_Sq

//初始條件：棧S存在
//操作結果：若為空棧，返回TRUE，否則FALSE
Status StackEmpty_Sq(SqStack S){
    if(S.top == S.base){
        cout<<"棧為空！"<<endl;
        return TRUE;
        }
    else{
        cout<<"棧不為空！"<<endl;
        return FALSE;
        }
}//StackEmpty_Sq

//初始條件：棧S存在
//操作結果：返回棧內元素個數，即棧的長度
int StackLength_Sq(SqStack S){
    int len;
    len = (S.top - S.base);
    return len;
}//StackLength_Sq

//初始條件：棧S存在
//操作結果：用e返回S的棧頂元素
Status GetTop_Sq(SqStack S, SElemType &e){
    if(S.top == S.base)//判空
        return ERROR;
    else{
        e = *(S.top - 1);
        return OK;
 }
}//GetTop_Sq

//初始條件：棧S存在
//操作結果：插入元素e為新的棧頂元素
Status Push_Sq(SqStack &S, SElemType e){
    //判滿，追加儲存空間
    if(S.top - S.base >= S.stacksize){
        S.base = (SElemType *)realloc(S.base,
          (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
        if(!S.base)//儲存分配失敗
            exit(OVERFLOW);
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++ = e; //插入元素
    return OK;
}//Push_Sq

//初始條件：棧S存在
//操作結果：刪除S的棧頂元素，並用e返回其值
Status Pop_Sq(SqStack &S, SElemType &e){
    if(S.top == S.base) //判空
        return ERROR;
    e = *--S.top; //返回刪除元素的值
    return OK;
}//Pop_Sq

//初始條件：棧S存在
//操作結果：遍歷棧元素並顯示
Status StackTraverse_Sq(SqStack S){
    if(S.base){  //判斷棧是否存在
        if(S.top == S.base) //判空
            cout<<"此棧是個空棧！"<<endl;
        else{
            SElemType *p;
            p = S.top;
            while(p > S.base)
            {
                p--;
                cout<<*p<<"  ";
            }
            cout<<endl;
        }
        return OK;
    }else{
        cout<<"棧不存在！"<<endl;
        return ERROR;
    }

}//StackTraverse_Sq

sqStackText.cpp

用來測試順序棧的基本操作函式。

#include "base.h"
#include "sq_stack.h"
//用來測試順序棧的基本操作
int main(){
    SqStack S;
    SElemType e;
    InitStack_Sq(S);
    StackTraverse_Sq(S);
    //給空棧賦值
    for(e = 0; e<10; e++){
        Push_Sq(S, e);
    }
    cout<<"棧的遍歷：";
    StackTraverse_Sq(S);
    Push_Sq(S, 15);
    cout<<"壓棧15後棧的遍歷：";
    StackTraverse_Sq(S);
    Pop_Sq(S, e);
    cout<<"出棧後棧的遍歷：";
    StackTraverse_Sq(S);
    cout<<"被刪除的元素是："<<e<<endl;
    GetTop_Sq(S, e);
    cout<<"獲取棧頂元素："<<e<<endl;
    cout<<"棧的長度為（即棧內元素個數）："
                <<StackLength_Sq(S)<<endl;
    cout<<"判棧空：";
    StackEmpty_Sq(S);
    cout<<"清空棧!"<<endl;
    CleanStack_Sq(S);
    cout<<"判棧空：";
    StackEmpty_Sq(S);
    cout<<"銷燬棧：";
    DestroyStack_Sq(S);
    cout<<"再次銷燬棧：";
    DestroyStack_Sq(S);
    return OK;
}

程式執行結果：

鏈式棧：

link_stack.h

鏈式表的具體程式碼實現：

//link_stack.h  鏈式棧

//-------------棧的鏈式儲存表示----------------

#define STACK_INIT_SIZE 100 //儲存空間初始分配量
#define STACKINCREMENT 10 //儲存空間分配增量

typedef struct StackNode{
    SElemType date; //資料域
    struct StackNode *next;
}StackNode, *LinkStackPtr;

typedef struct LinkStack{
    LinkStackPtr top; //棧頂
    int count; //記錄棧元素個數
}*PLinkStack;
//----基本操作的函式原型說明-----------

//構建一個空棧S
Status InitStack_L(PLinkStack* S){
    //分配一個節點的初始化空間
    *S = (PLinkStack)malloc(sizeof(struct LinkStack));
    (*S)->top = NULL; //棧頂指標指向空
    (*S)->count = 0; //棧中元素個數初始為0
    return OK;
}//InitStack_L

//初始條件：棧S存在
//操作結果：清空棧
Status CleanStack_L(PLinkStack &S){
    LinkStackPtr p;
     //棧不為空時,進行迴圈，釋放每一個節點的空間
    while(S->top){
        p = S->top;
        S->top = S->top->next;
        S->count--;
        free(p);
    }
    return OK;
}//CleanStack_L

//銷燬棧S
Status DestroyStack_L(PLinkStack* S){
    CleanStack_L(*S); //先清空棧
    free(*S); //釋放棧所有空間
    cout<<"棧銷燬成功！"<<endl;
    return OK;
}//DestroyStack_L

//初始條件：棧S存在
//操作結果：若為空棧，返回TRUE，否則FALSE
Status StackEmpty_L(PLinkStack S){
    if(S->top){  //棧頂存在
        cout<<"棧不為空！"<<endl;
        return TRUE;
    }else{
        cout<<"棧為空！"<<endl;
        return FALSE;
    }
}//StackEmpty_L

//初始條件：棧S存在
//操作結果：返回棧內元素個數，即棧的長度
int StackLength_L(PLinkStack S){
    return S->count;
}//StackLength_L

//初始條件：棧S存在
//操作結果：用e返回S的棧頂元素
Status GetTop_L(PLinkStack S, SElemType &e){
    if(!S->top)
        return ERROR;
    e = S->top->date;
    return OK;
}//GetTop_L

//初始條件：棧S存在
//操作結果：插入元素e為新的棧頂元素
Status Push_L(PLinkStack &S, SElemType e){
    LinkStackPtr p = (LinkStackPtr)malloc(sizeof(struct StackNode));
    p->date = e;
    p->next = S->top;
    S->top = p;
    S->count++;
    return OK;
}//Push_L

//初始條件：棧S存在
//操作結果：刪除S的棧頂元素，並用e返回其值
Status Pop_L(PLinkStack &S, SElemType &e){
   LinkStackPtr p;
   if(!S->top){
        return ERROR;
   }
   e = S->top->date;
   p = S->top;
   S->top = S->top->next;
   S->count--;
   free(p);
   return OK;
}//Pop_L

//初始條件：棧S存在
//操作結果：遍歷棧元素並顯示
Status StackTraverse_L(PLinkStack S){
    if(S->top){
        LinkStackPtr p;
        p = S->top;
        while(p){
            cout<<p->date<<"  ";
            p = p->next;
        }
        cout<<endl;
        return OK;
    }else{
        cout<<"此棧為空棧！"<<endl;
        return OK;
    }
}//StackTraverse_L

linkStackText

鏈式棧的測試：

void linkStackText(){
    PLinkStack S;
    SElemType e;
    InitStack_L(&S);
    StackTraverse_L(S);
    //給空棧賦值
    for(e = 0; e<10; e++){
        Push_L(S, e);
    }
    cout<<"棧的遍歷：";
    StackTraverse_L(S);
    Push_L(S, 15);
    cout<<"壓棧15後棧的遍歷：";
    StackTraverse_L(S);
    Pop_L(S, e);
    cout<<"出棧後棧的遍歷：";
    StackTraverse_L(S);
    cout<<"被刪除的元素是："<<e<<endl;
    GetTop_L(S, e);
    cout<<"獲取棧頂元素："<<e<<endl;
    cout<<"棧的長度為（即棧內元素個數）："
                <<StackLength_L(S)<<endl;
    cout<<"判棧空：";
    StackEmpty_L(S);
    cout<<"清空棧!"<<endl;
    CleanStack_L(S);
    cout<<"棧的遍歷：";
    StackTraverse_L(S);
    cout<<"判棧空：";
    StackEmpty_L(S);
    cout<<"銷燬棧：";
    DestroyStack_L(&S);
}

鏈式棧測試執行結果：