順序棧的實現和兩棧共享空間

順序棧的實現和兩棧共享空間

 以后慢慢啟用個人博客：http://www.yuanrengu.com/

一.順序棧的實現     

       棧(stack)是限定僅在表尾進行插入或刪除操作的線性表。我們把允許插入和刪除的一端稱為棧頂(top)，另一端稱為棧底(bottom)，不含任何數據元素的棧稱為空棧。棧又稱為后進先出(Last In First Out)的線性表，簡稱LIFO結構。

理解棧的定義需要注意：

1. 首先他是一個線性表，也就是說，棧元素具有線性關系，即前驅后繼關系。只不過他是一種特殊的線性表而已。定義中說是在線性表的表尾進行插入和刪除操作，這里表尾是指棧頂，而不是棧底。
2. 他的特殊之處就在於限制了這個線性表的插入和刪除位置，他始終只在棧頂進行。這也就使得：棧底是固定的，最先進棧的只能在棧底。

      棧的插入操作，叫作進棧，也稱壓棧、入棧。棧的刪除操作，叫出棧，也稱彈棧。

     順序棧，即棧的順序存儲結構是利用一組地址連續的存儲單元依次存放自棧底到棧頂的數據元素，同時附設指針top指示棧頂元素在順序棧中的位置。

順序棧的定義：

typedef struct{
    ElemType *bottom;
    ElemType *top;
    int StackSize;
}SqStack;

其中，StackSize指示棧的當前可使用的最大容量。棧的初始化操作為：按設定的初始狀態分配量進行第一次存儲分配，bottom可稱為棧底指針，在順序棧中，他始終指向棧底的位置，如bottom的值為NULL，則表明棧結構不存在。稱top為棧頂指針，其初值指向棧底，即top=bottom可作為棧空的標記，每當插入新的棧頂元素時，指針top增1；刪除棧頂元素時，指針top減1，因此，非空棧中的棧頂指針始終在棧頂元素的下一個位置上。如下圖所示。

base = NULL;  //棧結構不存在
top = base;   //棧空

順序棧的實現：

頭文件stack.h

//stack.h

#define TRUE        1  
#define FALSE       0  
#define OK          1  
#define ERROR       0  
#define OVERFLOW    -1  
#define UNDERFLOW   -2  

 

//定義函數返回值類型  
typedef int  Status;  
//定義順序棧的數據元素的類型  
typedef int  ElemType;

   
//定義順序棧的存儲結構  

#define STACK_INIT_SIZE 100 //初始分配空間大小

#define INCREMENTSIZE   10 //存儲空間分配增量  
struct SeqStack{  
    ElemType    *bottom;    //棧底指針  
    ElemType    *top;       //棧頂指針  
    int      size;       //棧存儲空間大小  
};

//聲明順序棧的基本操作  
Status  InitStack(SeqStack &s);  //構造一個空棧
Status  DestroyStack(SeqStack &s);  //銷毀一個棧
Status  ClearStack(SeqStack &s);  //把棧置空
Status  StackEmpty(SeqStack s);  //判斷是否為空棧
Status  StackLength(SeqStack s);  //返回棧的長度（即元素個數）
Status  Push(SeqStack &s,ElemType e);  //元素入棧
Status  Pop(SeqStack &s,ElemType &e);  //元素出棧
Status  GetTop(SeqStack s,ElemType &e);  //返回棧頂元素
Status  StackTraverse(SeqStack s);   //遍歷棧

實現函數：stack.cpp

#include "stack.h"
#include <iostream>
using namespace std;

Status  InitStack(SeqStack &s)  
//操作結果：構造一個空棧S  
{   
    s.bottom=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));  
    if(s.bottom == NULL){  
        cout<<"嚴重錯誤：順序棧初始存儲空間分配失敗，程序退出";  
        exit(ERROR);  
    }   
    s.top=s.bottom;
    s.size=STACK_INIT_SIZE;   
    return OK;  
}  

Status  DestroyStack(SeqStack &s)  
//初始條件：棧s已存在  
//操作結果：棧s已被銷毀  
{  
    free(s.bottom);   
    s.bottom=s.top=NULL;  //s.bottom的值為NULL，表示順序棧不存在   
    s.size=0;  
    return OK;  
}  

Status  ClearStack(SeqStack &s)  
//初始條件：棧s已存在  
//操作結果：將s清為空棧  
{   
    s.top=s.bottom;  //s.top == s.bottom作為順序棧空的標記  
    return OK;  
}  

Status  StackEmpty(SeqStack s)  
//初始條件：棧s已存在  
//操作結果：若棧s為空棧，則返回TRUE，否則FALSE  
{  
    if(s.top == s.bottom)  
        return TRUE;  
    else 
        return FALSE;  
}  

Status StackLength(SeqStack s)  
//初始條件：棧s已存在  
//操作結果：返回s的元素個數，即棧的長度  
{  
    return s.top-s.bottom;  
}  

Status  Push(SeqStack &s,ElemType e)  
//初始條件：棧s已存在  
//操作結果：插入元素e成為新的棧頂元素  
{       
   if(s.top-s.bottom >= s.size ){   
        s.bottom=(ElemType*)realloc(s.bottom,(s.size+INCREMENTSIZE)*sizeof(ElemType));  
        if(s.bottom == NULL){  
            cout<<"嚴重錯誤：順序棧增量存儲空間分配失敗，程序退出！";  
            exit(OVERFLOW);  
        }    
        s.top=s.bottom+s.size;   
        s.size+=INCREMENTSIZE;  
    }   

   // *s.top=e;
    //s.top++;  
   *s.top++ = e;
    return OK;  
}  

Status  Pop(SeqStack &s,ElemType &e)  
//初始條件：棧s已存在且非空  
//操作結果：刪除s的棧頂元素，並且用e返回其值  
{  
    if(StackEmpty(s) == TRUE){  
        cout<<"順序棧為空，出棧失敗！"<<endl;  
        exit(UNDERFLOW);  
    }  
   // s.top--;
   // e=*s.top;  
    e = *--s.top;
    return OK;  
}   
 
Status  GetTop(SeqStack s,ElemType &e)  
//初始條件：棧s已存在且非空  
//操作結果：用e返回s的棧頂元素  
{  
    if( StackEmpty(s) == TRUE ){  
        cout<<"訪問棧頂元素發生錯誤：棧為空"<<endl;  
        exit(UNDERFLOW);  
    }   
    return *(s.top-1);  
}  

Status  StackTraverse(SeqStack s)  
//初始條件：棧s已存在且非空  
//操作結果：從棧底開始依次輸出
{  
    if(s.bottom == NULL){  
        cout<<"嚴重錯誤：棧不存在，程序退出！";  
        exit(ERROR);  
    }   
    for(int i=0;i < StackLength(s);i++)   
    //    cout<<s.bottom[i]<<endl;   
        cout<<s.bottom[i]<<endl;  
    return OK;  
}

測試函數：

//test.cpp

#include "stack.h"   
#include <iostream>
using namespace std;

//獲取隨機整數  
int RangedRand( int range_min, int range_max)   
{   
   // Generate random numbers in the half-closed interval   
   // [range_min, range_max). In other words,   
   // range_min <= random number < range_max   
   int u =(int)( (double)rand() / (RAND_MAX + 1) * (range_max - range_min)   
            + range_min );    
   return u;   
}   
  
  
int main()   
{   
    struct SeqStack s;   
    InitStack(s);     
    ElemType data[10];   
    for(int i=0;i<10;i++){   
        data[i]=RangedRand(-500,500);   
        Push(s,data[i]);   
    }   
  
    StackTraverse(s);   
    cout<<"順序棧的長度是："<<StackLength(s)<<endl;   
  
    ElemType e;   
    Pop(s,e);   
    cout<<"棧頂元素"<<e<<"出棧"<<endl;   
    cout<<"此時的順序棧："<<endl;   
    StackTraverse(s);   
    cout<<"順序棧的長度是："<<StackLength(s)<<endl;   
  
    DestroyStack(s);   
    StackTraverse(s);   
    cout<<"順序棧的長度是："<<StackLength(s)<<endl;   


    return 0;   
}

 

二.兩棧共享空間

      如果我們有兩個相同類型的棧，我們為他們各自開辟了數組空間，極有可能第一個棧已經滿了，再進棧就溢出了，而另一個棧還有很多存儲空間空閑。這時，我們完全可以用一個數組兩存儲兩個棧。

      我們的做法如下圖，數組有兩個端點，兩個棧有兩個棧底，讓一個棧的棧底為數組的始端，即下標為0處，另一個棧為數組的末端，即下標為數組長度n-1處。這樣，兩個棧如果增加元素，就是兩端點向中間延伸。

     其實關鍵思路是：他們是在數組的兩端，向中間靠攏。top1和top2是棧1和棧2的棧頂指針，可以想象，只要他們兩不見面，兩個棧就可以一直使用。

     從這里也就可以分析出來，棧1為空時，就是top1等於-1時；而當top2等於n時，即是棧2為空時，那么什么時候棧滿呢？

     想想極端的情況，若棧2是空棧，棧1的top1等於n-1時，就是棧1滿了。反之，當棧1為空棧時，top2等於0時，為棧2滿。但更多的情況，其實就是剛才說的，兩個棧見面之時，也就是兩個指針之間相差1時，即top1+1==top2為棧滿。

     兩棧共享空間的結構的代碼如下：

typedef struct
{
    ElemType data[MAXSIZE];
    int top1;  //棧1棧頂指針
    int top2;  //棧2棧頂指針
}SqDoubleStack;

      對於兩棧共享空間的push方法，我們除了要插入元素值參數外，還需要有一個判斷是棧1還是棧2的棧號參數stackNumber。插入元素的代碼如下：

Status Push(SqDoubleStack *s , ElemType e , int stackNumber)
{
    if(s->top1+1 == s->top2)       //棧已滿，不能再push新元素了
        return ERROR;
    if(stackNumber == 1)           //棧1有元素進棧
        s->data[++s->top1] = e;    //若棧1則先top+1后給數組元素賦值
    else if(stackNumber == 2)      //棧2有元素進棧
        s->data[--s->top2] = e;    //若棧2則先top2-1后給數組元素賦值
    return OK;

}

      因為在開始已經判斷了是否有棧滿的情況，所以后面的top1+1或top2-1是不擔心溢出問題的。

      對於兩棧共享空間的pop方法，參數就只是判斷棧1棧2的參數stackNumber，代碼如下：

//若棧不空，則刪除s的棧頂元素，用e返回其值，並返回OK；否則返回ERROR
Status Pop(SqDoubleStack *s , ElemType *e , int stackNumber)
{
    if(stackNumber == 1)
    {
        if(s->top1 == 1)
            return ERROR;            //說明棧1已經是空棧，溢出
        *e = s->data[s->top1--];     //將棧1的棧頂元素出棧 
    }
    else if(stackNumber == 2)
    {
        if(s->top2 == MAXSIZE)
            return ERROR;            //說明棧2已經是空棧，溢出
        *e = s->data[s->top2++];     //將棧2的棧頂元素出棧
    }
    return OK;
}

      事實上，使用這樣的數據結構，通常都是當兩個棧的空間需求有相反關系時，也就是一個棧增長時另一個棧在縮短的情況。

      注意：這只是針對兩個具有相同數據類型的棧。