顺序栈的简单操作

关于顺序栈的简单操作如下， 由于主要介绍思想实现，读者从代码中可以很容易看出很多漏洞。如有错误之处，请大家指正！

点击(此处)折叠或打开

1. #include<iostream>
   
2. using namespace std;
   
3. #define MAXSIZE 10
   
4. 
   
5.  struct Stack {
   
6. 
   
7.     int data[MAXSIZE];
   
8.     int top;
   
9. };
   
10. 
    
11.  Stack *CreateStack();     //该步骤函数声明必须放在结构体后面
    
12.  void InitialStack(Stack *);
    
13.  void InsertStack(Stack *, int, int);
    
14.  void DeleteStack(Stack *, int);
    
15.  void PrintStack(Stack *);
    
16. 
    
17. Stack *CreateStack() {
    
18. 
    
19.     Stack *p = new Stack;  //创建指向栈的指针p
    
20.     p->top = -1;           //因为是顺序栈，存储数据放在数组中，为了一致性，top指针置于-1，表明栈为空
    
21.     return p;
    
22. 
    
23. }
    
24. 
    
25. void InitialStack(Stack *p) {
    
26. 
    
27.     Stack *head;
    
28.     head = p;
    
29. 
    
30.     cout << "入栈的顺序是：" << endl;
    
31.     
    
32.     int MAX_SIZE = MAXSIZE - 1;
    
33. 
    
34.     while (head->top != MAX_SIZE - 1) {
    
35. 
    
36.         head->top++;   //该步可以省略，下步改为：head->data[++head->top] = head->top;就是赋值与自加的先后顺序
    
37.         head->data[head->top] = head->top;
    
38.         cout << head->data[head->top] << "--&gt";
    
39.     }
    
40. 
    
41.     cout << "输出结束";
    
42.     cout << endl;
    
43.     
    
44. }
    
45. 
    
46. void InsertStack(Stack *p, int i, int x) {
    
47.     
    
48.     Stack *q;
    
49. 
    
50.     int length = p->top; //这里一定要注意，栈只能从一端进入弹出，要保证top指针不能够被修改
    
51.     p->top += 1;         //由于插入一个数据，栈长度+1（更准确的说是数组下标+1）
    
52.     q = p;
    
53. 
    
54.     int llength = q->top;
    
55.     int flag = llength;
    
56. 
    
57.     for (int n = 0; n <= flag - i; n++) { //一定要保证变与不变，算法实现，通过图解读者可以清楚知道各参数意义
    
58. 
    
59.         q->data[llength--] = q->data[length--]; 
    
60.     }
    
61. 
    
62.     q->data[i -1] = x;
    
63. 
    
64.     
    
65. }
    
66. 
    
67. void DeleteStack(Stack *p, int i) {
    
68. 
    
69.     Stack *q;
    
70. 
    
71.     int length = p->top;
    
72.     q = p;
    
73. 
    
74.     int l = i;
    
75.     int j = i - 1;
    
76. 
    
77.     for (int n = 0; n <= length - l+1; n++) {
    
78. 
    
79.         q->data[j++] = q->data[i++];   //删除操作，对于数组很简单就是覆盖操作
    
80.     }
    
81. 
    
82.     p->top = p->top - 1;
    
83. 
    
84.    
    
85. }
    
86. void PrintStack(Stack *p) {
    
87. 
    
88.     Stack *q;
    
89.     q = p;
    
90. 
    
91.     cout << "出栈的顺序是：" << endl;
    
92. 
    
93.     while (q->top >=0) {
    
94. 
    
95.         cout << q->data[q->top--] << "--&gt";
    
96.         
    
97.     }
    
98. 
    
99.     cout << "出栈结束" << endl;
    
100. }
     
101. 
     
102. int main() {
     
103. 
     
104.     Stack *p;
     
105. 
     
106.     p = CreateStack();
     
107.      InitialStack(p);
     
108. 
     
109.    // InsertStack(p, 5, 11);
     
110.     //PrintStack(p);
     
111. 
     
112.     DeleteStack(p, 5);
     
113.     PrintStack(p);
     
114. }

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/29876893/viewspace-1814693/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/29876893/viewspace-1814693/