栈

动态栈：
1、top = bottom ，栈空；
2、结点进栈：先把数据保存到栈顶，top指向的当前位置，然后top+1，然后top指向下一个位置；
3、结点出栈：首先top-1，使top指向栈顶元素，然后把栈顶元素取出。

 

 1 #define STACK_SIZE 100
 2 #define STACKINCREMENT 10
 3 #define ERR -1
 4 #define OK 0
 5 
 6 
 7 
 8 typedef int ElemType
 9 
10 typedef struct sqstack
11 {
12 　　ElemType *bottom;
13 　　ElemType *top;
14 　　int stacksize;
15 }SqStack;
16 
17 int Init_Stack(void)
18 {
19     SqStack s;
20     s.bottom = (ElemType*)malloc(STACK_SIZE * sizeof(ElemType));
21     if(!s.bottom)
22         return ERR;
23     s.top = s.bottom;
24     s.stacksize = STACK_SIZE;
25 
26     return OK;
27 }
28 
29 int dy_push(SqStack s,ElemType e)
30 {
31     if (s.top - s.bottom >= s.stacksize - 1)   //栈满，重新分配内存，长度为stack_size+stackincrement
32     {
33         s.bottom=(ElemType*)realloc(s.bottom, (STACK_SIZE + STACKINCREMENT) * sizeof(ElemType));
34         if (!s.bottom)
35         {
36             return ERR;
37         }
38         s.top = s.bottom + s.stacksize;
39         s.stacksize += STACKINCREMENT;
40     }
41     *s.top = e;
42     s.top++;
43     return OK;
44 }
45 
46 int dy_pop(SqStack s, ElemType *e)
47 {
48     if (s.top == s.bottom)
49     {
50         return ERR;
51     }
52     s.top--;
53     e = s.top;
54         return OK;
55 }


栈的静态存储：
1、top = 0 栈空;
2、top 指向栈顶在数组中的存储位置;
3、结点进栈，首先top + 1，top指向新的栈顶位置，然后把数据元素保存到栈顶;
4、出栈，先把指向栈顶的元素取出，然后top - 1。

 1 typedef struct sqstacks
 2 {
 3     ElemType stack_array[MAX_STACK_SIZE];
 4     int top;
 5 }SqStackS;
 6 
 7 Sqstacks Init_Sqstacks()
 8 {
 9     SqStackS s;
10     s.top = 0; return s;
11 }
12 int Static_Push(SqStackS s, ElemType e)
13 {
14     if (s.top == MAX_STACK_SIZE - 1 )
15     {
16         return ERR;
17     }
18     s.top++;
19     s.stack_array[s.top] = e;
20     return OK;
21 }
22 
23 int Static_Pop(SqStackS s, ElemType e)
24 {
25     if (s.top == 0)
26     {
27         return ERR;
28     }
29     s.stack_array[s.top] = e;
30     s.top--;
31     return OK;
32 }

栈的链式存储：

 1 typedef struct Stack_Node
 2 {
 3     ElemType data;
 4     struct Stack_Node *next;
 5 };
 6 
 7 Stack_Node* Init_Link_Stack(void)
 8 {
 9     Stack_Node *top;
10     top = (Stack_Node *)malloc(sizeof(Stack_Node));
11     top->next = NULL;
12     return top;
13 }
14 
15 int Push_Link_Stack(Stack_Node *top, ElemType e)
16 {
17     Stack_Node *p;
18     p = (Stack_Node *)malloc(sizeof(Stack_Node));
19     if (!p)
20     {
21         return ERR;
22     }
23     p->data = e;
24     p->next = top->next;
25     top->next = p;
26     return OK;
27 }
28 
29 int Pop_Link_Stack(Stack_Node *top, ElemType e)
30 {
31     Stack_Node *p;
32     p = top->next;
33     if (top->next)
34     {
35         return ERR;
36     }
37     e = p->data;
38     top->next = p->next;
39     free(p);
40     return OK;
41 }

总结：

1、当栈满时 进栈产生溢出，叫上溢

2、当栈空时 出栈产生溢出，叫下溢

3、栈的初始状态和结束状态都是空栈，经常用下溢作为控制转移条件。

posted on 2015-12-29 15:07  重八  阅读(269)  评论(0)  编辑  收藏  举报

导航