数据结构（五）——栈

栈的定义：

栈是限定仅在表位进行插入和删除操作的线性表。允许插入和删除的一端称为栈顶，另一端为栈底，不含任何数据元素的栈称为空栈。

栈的插入操作，叫做进栈，也叫做压栈，入栈，打个比方，像子弹如弹夹；栈的删除操作，叫做出栈，有的叫做弹栈，如同子弹出弹夹。示意图如下：

栈的顺序存储结构及实现：

[cpp]  view plain  copy

 

1. typedef struct  
2. {  
3.     int data[MAXSIZE];  
4.     int top; /*用于栈顶指针*/  
5. }SqStack;  

进栈操作：

[cpp]  view plain  copy

 

1. int push(SqStack *s, int e) /*int 可根据实际情况改变*/  
2. {  
3.     if(s->top == MAXSIZE -1)  /*栈满*/  
4.     {  
5.     return error;  
6.     }  
7.     s->top++;   /*栈顶指针+1*/  
8.     s->data[s->top] = e;  /*将新元素赋值给栈顶空间*/  
9.     return success;  
10. }  

出栈操作：

[cpp]  view plain  copy

 

1. int pop(SqStack *s, int *e) /*int 可根据实际情况改变*/  
2. {  
3.     if(s->top == -1)  /*栈满*/  
4.     {  
5.     return error;  
6.     }  
7.     *e = s->data[s->top];  
8.     s->top--;   /*栈顶指针-1*/  
9.     return success;  
10. }  

两栈共享空间：

因为栈的大小是事先确定的，万一不够用，就需要扩展栈的容量，我们可以将两个相同类型的栈共用。做法如下图：
关键思路：
他们是在数组的两端，向中间靠拢，top1和top2是两个栈的栈顶指针，只要这两个不见面，两个栈就能使用。栈1空是，top1==-1，top2==n时，栈2为空。

栈满的情况：

若栈2空，top1 == n - 1，栈1满；栈1空，top2==0，栈2满；更多的情况是top1+1 == top2为栈满。

代码如下：

[cpp]  view plain  copy

 

1. /*两栈共享空间结构*/  
2. typedef struct  
3. {  
4.     int data[MAXSIZE];  
5.     int top1;  
6.     int top2;  
7. }SqDoubleStack;  

对于两栈共享空间的push方法，需要有一个判断栈1还是栈2的参数stackNumber。

push代码：

[cpp]  view plain  copy

 

1. int push(SqDoubleStack *s, int e，int stackNumber) /*int 可根据实际情况改变*/  
2. {  
3.     if(s->top1 + 1 == s->top2)  /*栈满*/  
4.     {  
5.     return error;  
6.     }  
7.     if(1 == stackNumber)  
8.     {  
9.     s->data[++s->top1] = e;  
10.     }  
11.     else if(2 == stackNumber)  
12.     {  
13.     s->data[++s->top2] = e;  
14.     }  
15.     return success;  
16. }  

pop同理：

[cpp]  view plain  copy

 

1. int pop(SqDoubleStack *s, int *e，int stackNumber) /*int 可根据实际情况改变*/  
2. {  
3.     if(1 == stackNumber)  
4.     {  
5.     if(-1 == s->top1)  
6.     {  
7.         return error;  
8.     }  
9.     *e = s->data[s->top1--];  
10.     }  
11.     else if(2 == stackNumber)  
12.     {  
13.     if(MAXSIZE == s->top2)  
14.     {  
15.         return error;  
16.     }  
17.     *e = s->data[s->top2++];  
18.     }  
19.     return success;  
20. }  

介绍玩栈的顺序存储结构，下面介绍栈的链式存储结构。

对于链栈来说，不存在栈满的情况；但是对于空栈来说，链栈的头指针指向空，即top==NULL时。链栈的结构代码如下：

[cpp]  view plain  copy

 

1. typedef struct StackNode  
2. {  
3.     int data;  
4.     struct StackNode *next;  
5. }StackNode,*LinkStackPtr;  
6.   
7. typedef struct LinkStack  
8. {  
9.     LinkStackPtr top;  
10.     int count;  
11. }LinkStack;  

链式栈的进栈和出栈操作与顺序存储结构的有所不同，下面是示意图和代码：

上图是进栈示意图，下面是代码演示：

[cpp]  view plain  copy

 

1. int push(SqStack *s, int e) /*int 可根据实际情况改变*/  
2. {  
3.     LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode));  
4.     s->data = e;  
5.     s->next = s->top; /*把当前栈顶元素赋值给新结点的直接后继，如上图步骤1*/  
6.     s->top = s;    /*将新结点s赋值给栈顶指针如步骤2*/  
7.     s->count++;  
8.     return success;  
9. }  

出栈示意图和代码：

代码：

[cpp]  view plain  copy

 

1. int pop(SqStack *s, int *e) /*int 可根据实际情况改变*/  
2. {  
3.     LinkStackPtr p;  
4.     if(StackEmpty(*s))   /*空栈*/  
5.     {  
6.     return error;  
7.     }  
8.     *e = s->top->data;  
9.     p = s->top;   /*栈顶结点赋值给p*/  
10.     s->top = s->top->next； //下移  
11.     free(p);   //释放p  
12.     s->count--；  
13.   
14.     return success;  
15. }