c语言实现栈的基本操作

时光季

C语言如何实现栈的基本操作、求源代码。

风之残月

翻书吧，书上都有

shisecao

好好学习，天天向上

三哥自尊心强

这个应该很多的。栈的基本操作的东西网上比较多。

tlwangxd

关注

赵晓玉

看小甲鱼的视频  有讲的 上机打出的代码

BeatificDevin

1. typedef struct sqStack
   
2. {
   
3.     ElemType *top;
   
4.     ElemType *base;
   
5.     int initSize;
   
6. }sqStack;
   
7. typedef struct sqStack *LinkStack;
   
8. 
   
9. //初始化
   
10. void InitStack(sqStack *s)
    
11. {
    
12.     s->base = (LinkStack)malloc(Stack_Init_Size * sizeof(ElemType));
    
13.     if(!s->base)
    
14.     {
    
15.         printf("存储空间分配失败······\n");
    
16.         return;
    
17.     }
    
18.     s->top = s->base;
    
19.     s->initSize = Stack_Init_Size;
    
20. }
    
21. //进栈
    
22. void Push(sqStack *s,ElemType *e)
    
23. {
    
24.     if(s->top - s->base >= s->initSize - 1)
    
25.     {
    
26.         s->base = (LinkStack)realloc(s->base,(s->initSize + Increase_Size) * sizeof(ElemType));
    
27.         //第一个s->base是增加后的存储空间块的地址，第二个是增加空间之前的存储空间块地址，后面是增加过的存储空间块的大小
    
28.         if(!s->base)
    
29.         {
    
30.             printf("增加存储空间失败······\n");
    
31.             return;
    
32.         }
    
33.         s->initSize = Increase_Size + Stack_Init_Size;
    
34.     }
    
35.     *(s->top) = *e;
    
36.     (s->top)++;
    
37. }
    
38. //出栈
    
39. void Pop(sqStack *s,ElemType *e)
    
40. {
    
41.     if(s->top == s->base)
    
42.     {
    
43.         printf("栈已空，无法进行出栈操作······\n");
    
44.         return;
    
45.     }
    
46.     s->top--;
    
47.     *e = *s->top;
    
48. }
    
49. //求栈的长度
    
50. int StackLen(sqStack s)
    
51. {
    
52.     return (s.top - s.base);
    
53. }

复制代码

BeatificDevin

http://www.cnblogs.com/devinblog/
最近在博客上也写了一点程序，你可一看看，希望对你有帮助

赵晓玉

小甲鱼有视频的  自己去看下

xueying

mark

xueying

mark

xueying

1. //2014.10.02        顺序栈的实现方式
   
2. #include<iostream>
   
3. #include<math.h>
   
4. #include"assert.h"
   
5. using namespace std;
   
6. 
   
7. #define INCREMENT_SIZE 2
   
8. typedef struct STACK
   
9. {
   
10.         int stacksize;
    
11.         int* pstop;                        //栈顶指针p表示指针s表示栈
    
12.         int* psbottom;
    
13. }STACK;
    
14. 
    
15. void init_stack(STACK& s)
    
16. {
    
17.        
    
18.         s.stacksize = INCREMENT_SIZE;
    
19.         //注意加1的原因：s.psbottom不存放数据本身要占据一个字节的空间
    
20.         s.pstop = s.psbottom =(int*)malloc(sizeof(int)*(s.stacksize+1));
    
21.         if(NULL ==         s.pstop)
    
22.         {
    
23.                 cout<<"为栈分配存储空间失败";
    
24.                 return;
    
25.         }
    
26.        
    
27. }
    
28. 
    
29. 
    
30. 
    
31. bool push(STACK& s,int val)
    
32. {
    
33.        
    
34.         int k = s.pstop-s.psbottom;
    
35.         if((s.pstop-s.psbottom)>=s.stacksize)
    
36.         {
    
37.                 //注意加1的原因：s.psbottom不存放数据本身要占据一个字节的空间
    
38.                 s.psbottom = (int*)realloc(s.psbottom ,sizeof(int)*(s.stacksize+INCREMENT_SIZE+1));
    
39.                 if(NULL == s.psbottom)
    
40.                 {
    
41.                         cout<<"栈已满，为将要压栈的元素分配内存失败"<<endl;
    
42.                         return false;
    
43.                 }
    
44.                 s.pstop = s.psbottom+s.stacksize;
    
45.                 s.stacksize+=INCREMENT_SIZE;
    
46.         }
    
47.                 s.pstop++;
    
48.                 *s.pstop = val;
    
49.        
    
50.                 return true;
    
51. }
    
52. 
    
53. bool pop(STACK& s,int& val)
    
54. {
    
55.         if(s.psbottom == s.pstop)
    
56.         {
    
57.                 cout<<"栈为空出栈失败"<<endl;
    
58.                 return false;
    
59.         }
    
60. 
    
61.         val = *s.pstop--;
    
62.         return true;
    
63. }
    
64. void dis_stack(STACK& s)
    
65. {
    
66.         if(s.pstop == s.psbottom)
    
67.         {
    
68.                 cout<<"栈为空"<<endl;
    
69.                 return ;
    
70.         }
    
71.        
    
72.         int* p = s.pstop ;
    
73.         while(p != s.psbottom)
    
74.         {
    
75.                 cout<<*p<<endl;
    
76.                 p--;
    
77.         }
    
78. }
    
79. 
    
80. 
    
81. bool get_top(STACK&s, int& val)
    
82. {
    
83.         if(s.psbottom == s.pstop)
    
84.         {
    
85.                 cout<<"栈为空"<<endl;
    
86.                 return false;
    
87.         }
    
88. 
    
89.         val = *s.pstop;
    
90.         return true;
    
91. }
    
92. 
    
93. STACK stack;
    
94. int main(void)
    
95. {
    
96.         init_stack(stack);
    
97.         push(stack,23);
    
98.         push(stack,78);
    
99.         push(stack,26);
    
100.         push(stack,90);
     
101.         push(stack,45);       
     
102.         push(stack,45);
     
103.         push(stack,78);
     
104.         push(stack,123);       
     
105.         dis_stack(stack);
     
106.         int val = 0;
     
107.         cout<<endl;
     
108.         pop(stack,val);
     
109.         cout<<val<<endl;
     
110.         cout<<endl;
     
111.         pop(stack,val);
     
112.         cout<<val<<endl;
     
113.         cout<<endl;
     
114.         dis_stack(stack);
     
115. 
     
116.         int top_val;
     
117.         get_top(stack,top_val);
     
118.         cout<<endl;
     
119.         cout<<top_val<<endl;
     
120.     return 0;
     
121. }

复制代码