栈

栈的实现：顺序栈与链栈

Stack.h

 1 /*
 2  *栈：
 3  *    基本操作集：1、初始化栈
 4  *                2、判栈空
 5  *                3、取栈顶
 6  *                4、进栈以及出栈
 7 */
 8 
 9 //顺序栈
10 #define Max_Size 15
11 typedef struct
12 {
13     int data[Max_Size];
14     int top;
15 }SqStack;
16 
17 void InitStack(SqStack* &s,int a[],int n);
18 void GetTop(SqStack s,int &e);
19 bool IsEmpty(SqStack s);
20 void Push(SqStack& s,int e);
21 void Pop(SqStack& s,int &e);
22 void DisplayStack(SqStack s);
23 
24 
25 //链栈
26 typedef struct LSNode
27 {
28     int data;
29     struct LSNode *next;
30 }LinkStack;
31 
32 void InitLStack(LinkStack* &s,int a[],int n);
33 void GetLTop(LinkStack s,int &e);
34 bool IsLEmpty(LinkStack s);
35 void LPush(LinkStack& s,int e);
36 void LPop(LinkStack& s,int &e);
37 void DisplayLStack(LinkStack s);

stack.cpp

  1 #include <iostream>
  2 #include "Stack.h"
  3 using namespace std;
  4 
  5 /*
  6  *顺序栈的实现
  7 */
  8 
  9 
 10 void InitStack(SqStack* &s,int a[],int n)   //Note:这里传递指针是传值，并非传地址。
 11 {
 12     s=(SqStack*)malloc(sizeof(SqStack));
 13     s->top=-1;
 14     for(int i=0;i<n;i++)
 15     {
 16         s->top++;
 17         s->data[s->top]=a[i];
 18     }
 19     if(s->top!=Max_Size)    //有待改善
 20     {
 21         for(int i=s->top+1;i<Max_Size;i++)
 22         {
 23             s->data[i]=0;
 24         };
 25     }
 26     cout<<endl;
 27 }
 28 
 29 void GetTop(SqStack s,int &e)
 30 {
 31     e=s.data[s.top];
 32 }
 33 
 34 bool IsEmpty(SqStack s)
 35 {
 36     return s.top==-1?true:false;
 37 }
 38 
 39 void Push(SqStack &s,int e)
 40 {
 41     s.top++;
 42     s.data[s.top]=e;
 43     cout<<endl;
 44 }
 45 
 46 void Pop(SqStack &s,int &e)
 47 {
 48     e=s.data[s.top];
 49     s.data[s.top]=0;
 50     s.top--;
 51     cout<<endl;
 52 }
 53 
 54 void DisplayStack(SqStack s)
 55 {
 56     int num=sizeof(s.data)/sizeof(int);
 57     for(int i=0;i<num;i++)
 58     {
 59         cout<<s.data[i]<<"";
 60     }
 61     cout<<endl;
 62 }
 63 
 64 
 65 /*
 66  *链栈的实现
 67 */
 68 
 69 
 70 void InitLStack(LinkStack* &s,int a[],int n)
 71 {
 72     s=(LinkStack*)malloc(sizeof(LinkStack));
 73     s->next=NULL;
 74     LinkStack *p;
 75     for(int i=0;i<n;i++)
 76     {
 77         p=(LinkStack*)malloc(sizeof(LinkStack));
 78         p->data=a[i];
 79         p->next=s->next;
 80         s->next=p;
 81     }
 82     cout<<endl;
 83 }
 84 void GetLTop(LinkStack s,int &e)
 85 {
 86     e=s.next->data;
 87 }
 88 bool IsLEmpty(LinkStack s)
 89 {
 90     return s.next==NULL?true:false;
 91 }
 92 void LPush(LinkStack& s,int e)
 93 {
 94     LinkStack *p;
 95     p=(LinkStack*)malloc(sizeof(LinkStack));
 96     p->data=e;
 97     p->next=s.next;
 98     s.next=p;
 99 }
100 void LPop(LinkStack& s,int &e)
101 {
102     e=s.next->data;
103     s.next=s.next->next;
104 }
105 
106 
107 void DisplayLStack(LinkStack s)
108 {
109     LinkStack *p=s.next;
110     while(p)
111     {
112         cout<<p->data<<"";
113         p=p->next;
114     }
115     p=NULL;
116     cout<<endl;
117 }

测试:index.cpp

 1 #include <iostream>
 2 #include "Stack.h"
 3 using namespace std;
 4 
 5 int main()
 6 {
 7 /*
 8  *栈
 9 */
10 //    ------------顺序栈-----------
11 
12 //初始化栈
13     int ss[10]={0,1,2,3,4,5,6,7,8,9};
14     SqStack* S=NULL;
15     InitStack(S,ss,10);
16     DisplayStack(*S);
17 
18     ////通过地址传递
19     //int s1=4,s2=3;
20 //swap(s1,s2);
21 //cout<<s1<<" "<<s2<<endl;
22 
23 //取栈顶
24     int sr=0;
25     GetTop(*S,sr);
26     cout<<sr<<endl;
27 
28     //判栈空
29     bool is_empty=IsEmpty(*S);
30     if(is_empty)
31     {
32         cout<<"Yes,It's a empty stack!!!"<<endl;
33     }
34     else
35     {
36         cout<<"No,It has elements!!!"<<endl;
37     }
38 
39     //将10和11进栈
40     int to1=10,to2=11;
41     Push(*S,to1);
42     Push(*S,to2);
43     DisplayStack(*S);
44 
45     //将11出栈
46     int from2=0;
47     Pop(*S,from2);
48     DisplayStack(*S);
49     cout<<"The element pops from stack is "<<from2<<endl<<endl;
50 
51 
52 //    ------------链栈-----------
53 
54 //初始化栈:这里只能使用头节点插入的方法创建
55     int ls[10]={0,1,2,3,4,5,6,7,8,9};
56     LinkStack* LS=NULL;
57     InitLStack(LS,ls,10);
58     DisplayLStack(*LS);
59 
60         //取栈顶
61     int stop=0;
62     GetLTop(*LS,stop);
63     cout<<"The top element is "<<stop<<endl;
64 
65 
66          //判栈空
67     bool is_lempty=IsLEmpty(*LS);
68     if(is_lempty)
69     {
70         cout<<"Yes,It's a empty linkstack!!!"<<endl;
71     }
72     else
73     {
74         cout<<"No,It has elements!!!"<<endl;
75     }
76 
77        //将10和11进栈
78     int tol1=10,tol2=11;
79     LPush(*LS,tol1);
80     LPush(*LS,tol2);
81     DisplayLStack(*LS);
82 
83        //将11出栈
84     int froml2=0;
85     LPop(*LS,froml2);
86     cout<<"The element pops from stack is "<<froml2<<endl<<endl;
87     DisplayLStack(*LS);
88 
89 // ------------共享栈-----------
90 //    栈1和栈2共享一块0~MaxSize-1的地址空间,top1、top2分别是栈1和栈2的栈顶;
91 //栈1的基本操作集与一般的栈无异，栈2却有些许改变：(1)判栈空：top2==MaxSize；
92 //                                                (2)进栈：先top2--,再赋值；
93 //                                                (3)出栈：先赋值，后top2++；
94 //                                                (4)初始化栈与取栈顶只有些许改变，略去！！！
95 
96 
97     return 0;
98 }

结果示下：

转载于:https://www.cnblogs.com/zengge/archive/2011/11/02/2232633.html