数据结构-栈的顺序结构两种方式

第一种结构:

  存储空间有限,适用于知道存储长度的情况下。操作实现很简单。

 1 #include "stdio.h"
 2 
 3 
 4 #define MAXSIZE 50
 5 #define STACKINCREMENT 10
 6 #define OK 1
 7 #define ERROR 0
 8 typedef int SElemType;
 9 typedef int Status;
10 
11 typedef struct
12 {
13     SElemType data[MAXSIZE];    //存储数组
14     int top;                    //栈顶
15 }Stack;
16 
17 //初始化栈
18 Status InitStack(Stack &S)
19 {
20     S.top = -1;        //栈顶指向-1代表空栈
21     return OK;
22 }
23 
24 //重置栈为空栈
25 Status ClearStack(Stack &S)
26 {
27     S.top = -1;    //与初始化一样道理
28     return OK;
29 }
30 
31 //判断栈是否为空,空栈返回OK 否则返回ERROR
32 Status StackEmpty(Stack S)
33 {
34     if(S.top < 0)
35         return OK;
36     else
37         return ERROR;
38 }
39 
40 //返回栈的长度
41 int StackLength(Stack S)
42 {
43     return S.top+1;    //因为top值是做数组下标所以比长度小一
44 }
45 
46 //若栈不为空 用e返回栈顶数据 并返回OK 否则返回ERROR
47 Status GetTop(Stack S, SElemType &e)
48 {
49     if(StackEmpty(S))
50         return ERROR;
51     e = S.data[S.top];
52     return OK;
53 }
54 
55 //若栈不为空 把e插入栈顶 并返回OK 否则返回ERROR
56 Status Push(Stack &S, SElemType e)
57 {
58     if(S.top >= MAXSIZE-1)
59         return ERROR;
60     S.top++;
61     S.data[S.top] = e;
62     return OK;
63 }
64 
65 //若栈不为空 删除栈顶数据 并用e返回值 并返回OK 否则返回ERROR
66 Status Pop(Stack &S, SElemType &e)
67 {
68     if(StackEmpty(S))
69         return ERROR;
70     if(StackEmpty(S))
71         return ERROR;
72     e = S.data[S.top];
73     S.top--;
74     return OK;
75 }
76 
77 //遍历Visit()函数
78 Status StackTraverse(Stack S, void (* Visit)(SElemType e))
79 {
80     for (int i = 0; i <= S.top; i++)
81         Visit(S.data[i]);
82     printf("\n");
83     return OK;
84 }
85 
86 //StackTraverse调用函数
87 //在这里为输出数据
88 void Visit(SElemType e)
89 {
90     printf("%d ", e);
91 }

  因为数据是存储在数组之中,所以没有销毁栈的基本操作函数

第二种结构:

  相比第一种结构这种方法可以在上限的存储时增加存储容量的大小,使用更加灵活。操作实现依旧简单。

  1 #include "stdio.h"
  2 #include "stdlib.h"
  3 
  4 typedef int Status;        //存储空间初始分配
  5 typedef int SElemType;    //存储空间分配增量
  6 #define ERROR 0
  7 #define OK 1
  8 #define STACK_INIT_SIZE 100
  9 #define STACKINCREMENT 10
 10 
 11 typedef struct
 12 {
 13     SElemType * base;    //在栈构造之前和销毁之后base的值为NULL
 14     SElemType * top;    //栈顶指针
 15     int StackSize;        //当前已分配的存储空间,以元素为单位
 16 }Stack;
 17 
 18 //构造一个空栈
 19 Status InitStack (Stack &S)
 20 {
 21     S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));    //分配基本空间
 22     if(!S.base)            //判断是否分配成功
 23         return ERROR;
 24     S.top = S.base;        //指向栈顶
 25     S.StackSize = STACKINCREMENT;    //初始链表最大长度
 26     return OK;
 27 }//InitStack
 28 
 29 //销毁一个栈
 30 Status DestroyStack(Stack &S)
 31 {
 32     free(S.base);            //收回空间
 33     S.top = S.base = NULL;    //栈顶和base均指向空
 34     return OK;
 35 }
 36 
 37 //重置表为空表
 38 Status ClearStack(Stack S)
 39 {
 40     S.top = S.base;//栈顶指向首位代表表空
 41     return OK;
 42 }
 43 
 44 //若S为空栈返回OK 否则返回ERROR
 45 Status StackEmpty(Stack S)
 46 {
 47     if (S.top == S.base)
 48         return OK;
 49     else
 50         return ERROR;
 51 }
 52 
 53 //返回栈的长度
 54 int StackLength(Stack S)
 55 {
 56     SElemType * p = S.base;
 57     int i = 0;                //计数值为表长
 58     while(p != S.top)
 59     {
 60         p++;
 61         i++;
 62     }
 63     return i;
 64 }
 65 
 66 //若栈不空则用e返回栈顶数据并返回OK否则返回ERROR
 67 Status GetTop(Stack S, SElemType &e)
 68 {
 69     if (StackLength(S) == 0)    //空栈
 70         return ERROR;
 71     e = *S.top;    
 72     return OK;
 73 }
 74 
 75 //插入新的栈顶数据
 76 Status Push(Stack &S, SElemType e)
 77 {
 78     if(S.top - S.base >=S.StackSize)    //空间不足
 79     {
 80         S.base = (SElemType *)realloc(S.base, (S.StackSize + STACKINCREMENT) * sizeof(SElemType));
 81         if(!S.base)
 82             return ERROR;
 83         S.top = S.base + S.StackSize;
 84         S.StackSize += STACKINCREMENT;
 85     }
 86     S.top++;
 87     *S.top = e;
 88     return OK;
 89 }
 90 
 91 //若栈不空 则删除栈顶数据并用e返回且返回OK 否则返回ERROR
 92 Status Pop(Stack &S, SElemType &e)
 93 {
 94     if(StackLength(S) == 0)    //空栈
 95         return ERROR;
 96     e = *S.top;
 97     S.top--;
 98     return OK;
 99 }
100 
101 //对栈遍历Visit()函数
102 Status StackTraverse(Stack S, void (*Visit)(SElemType e))
103 {
104     SElemType * p = S.base;
105     while(p != S.top)
106         Visit(*++p);
107     printf("\n");
108     return OK;
109 }
110 
111 //StackTraverse调用函数
112 //在这里做输出栈表用
113 //顺序为栈底到栈顶
114 void Visit(SElemType e)
115 {
116     printf("%d ",e);
117 }

栈是限定仅在表尾进行插入和删除的操作线性表,因此栈的实现比较线性表显得更简单且容易实现。

参考《数据结构(C语言版)》严蔚敏编著

posted @ 2016-04-09 15:51  A_book  阅读(3064)  评论(0编辑  收藏  举报