【数据结构】 顺序栈的基本操作 （C语言版）
目录
一、顺序栈
1、顺序栈的定义：
2、顺序栈的优缺点
二、顺序栈的基本操作算法（C语言）
1、宏定义
2、创建结构体
3、顺序栈的初始化
4、顺序栈的入栈
5、顺序栈的出栈
6、取栈顶元素
7、栈的遍历输出
8、顺序栈的判空
9、顺序栈的判满
10、求顺序栈长度
11、顺序栈的清空
12、顺序栈的销毁
13、数制转换
14、括号匹配
三、顺序栈的基本操作完整代码（C语言）
四、运行结果
一、顺序栈
1、顺序栈的定义：
顺序栈是由一维数组实现的栈，其中栈底元素的下标为0，栈顶元素的下标为n-1（n为数组大小），栈的大小在创建时确定，且在栈的生命周期内保持不变。
2、顺序栈的优缺点
顺序栈的优点：
- 空间利用率高：由于数组的大小在创建时确定，因此可以预先分配足够的空间，避免了频繁的内存申请和释放操作，提高了空间利用率。
- 存取速度快：由于栈元素在内存中连续存储，因此可以根据下标直接访问栈底元素和栈顶元素，存取速度快。
- 方便进行动态扩展：在某些情况下，可以在栈外再开辟一块内存空间，将栈的大小动态扩展，从而方便处理大规模的数据。
顺序栈的缺点：
- 内存浪费：如果预分配的数组大小过大，会造成内存浪费；如果预分配的数组大小过小，则可能会频繁地进行内存申请和释放操作，降低性能。
- 不适合处理动态扩展的数据：顺序栈的空间大小在创建时确定，因此无法动态扩展，对于需要处理大规模数据的情况不太适用。
- 不便于处理异常情况：如果栈已满而仍需添加元素，会导致栈溢出；如果栈未满而尝试删除元素，会导致栈下溢。这些异常情况的处理较为复杂。
二、顺序栈的基本操作算法（C语言）
1、宏定义
#define OK 1
#define ERROR 0
#define MAXSIZE 100
typedef char SElemType;
typedef int Status;2、创建结构体
typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
} SqStack;3、顺序栈的初始化
//初始化
Status InitStack(SqStack &S) {
S.base = new SElemType[MAXSIZE];
if (!S.base)
return 0;
S.top = S.base;
S.stacksize = MAXSIZE;
return OK;
}4、顺序栈的入栈
//进栈
Status Push(SqStack &S, SElemType e) {
if (S.top - S.base == S.stacksize)
return 0;
*S.top++ = e;
return OK;
}5、顺序栈的出栈
//出栈
Status Pop(SqStack &S, SElemType &e) {
if (S.top == S.base)
return 0;
e = *(--S.top);
return OK;
}6、取栈顶元素
//获取栈顶元素
Status Top(SqStack &S, SElemType &e) {
if (S.top == S.base)
return ERROR;
e = *(S.top - 1);
return OK;
}7、栈的遍历输出
//栈的遍历输出
void printStack(SqStack S) {
printf("现在栈内元素为：");
SElemType *p = S.base;
while (p != S.top) {
printf("%c ", *p);
p++;
}
printf("\n");
}8、顺序栈的判空
//判空S.top == S.base
Status StackEmpty(SqStack S) {
if (S.top == S.base) {
return true;
} else {
return false;
}
}9、顺序栈的判满
//判满
Status FullEmpty(SqStack S) {
if (S.top - S.base == S.stacksize) {
return true;
} else {
return false;
}
}10、求顺序栈长度
//求顺序栈长度
Status StackLength(SqStack S) {
return S.top - S.base;
}11、顺序栈的清空
//清空
Status ClearStack(SqStack &S) {
S.top = S.base;
return OK;
}12、顺序栈的销毁
//销毁
Status DestroyStack(SqStack &S) {
if (S.base) {
delete S.base;
S.stacksize = 0;
S.top = S.base = NULL;
}
return OK;
}13、数制转换
//数制转换
void conversion(int N) {
SqStack S;
InitStack(S);
char e;
while (N) {
Push(S, N % 8);
N = N / 8;
}
while (!StackEmpty(S)) {
Pop(S, e);
printf("%d", e);
}
}14、括号匹配
//括号匹配
Status Matching() {
SqStack S;
InitStack(S);
SElemType ch, x;
Status flag = 1;
printf("请输入需要匹配的括号(以#结束)：\n");
//char ch = getche();
scanf("%c", &ch);
while (ch != '#' && flag) {
switch (ch) {
case '(':
case '[':
Push(S, ch);
break;
case ')':
if (!StackEmpty(S) && GetTop(S) == '(') {
Pop(S, x);
} else {
flag = 0;
}
break;
case ']':
if (!StackEmpty(S) && GetTop(S) == '[') {
Pop(S, x);
} else {
flag = 0;
}
break;
}
//ch = getche();
scanf("%c", &ch);
}
if (StackEmpty(S) && flag) {
return true;
} else {
return false;
}
}三、顺序栈的基本操作完整代码（C语言）
#include
#include //getchae()
#define OK 1
#define ERROR 0
#define MAXSIZE 100
typedef char SElemType;
typedef int Status;
//创建结构体
typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
} SqStack;
//初始化
Status InitStack(SqStack &S) {
S.base = new SElemType[MAXSIZE];
if (!S.base)
return 0;
S.top = S.base;
S.stacksize = MAXSIZE;
return OK;
}
//进栈
Status Push(SqStack &S, SElemType e) {
if (S.top - S.base == S.stacksize)
return 0;
*S.top++ = e;
return OK;
}
//求顺序栈长度
Status StackLength(SqStack S) {
return S.top - S.base;
}
//出栈
Status Pop(SqStack &S, SElemType &e) {
if (S.top == S.base)
return 0;
e = *(--S.top);
return OK;
}
//获取栈顶元素
Status Top(SqStack &S, SElemType &e) {
if (S.top == S.base)
return ERROR;
e = *(S.top - 1);
return OK;
}
//获取栈顶元素
SElemType GetTop(SqStack &S) {
if (S.top == S.base)
return ERROR;
return *(S.top - 1);
}
//栈的遍历输出
void printStack(SqStack S) {
printf("现在栈内元素为：");
SElemType *p = S.base;
while (p != S.top) {
printf("%c ", *p);
p++;
}
printf("\n");
}
//清空
Status ClearStack(SqStack &S) {
S.top = S.base;
return OK;
}
//销毁
Status DestroyStack(SqStack &S) {
if (S.base) {
delete S.base;
S.stacksize = 0;
S.top = S.base = NULL;
}
return OK;
}
//Status DestoryStack(SqStack &S) {
// if (S.base) {
// delete S.base;
// S.stacksize = 0;
// S.base = S.top = NULL;
// }
// return OK;
//}
//判空S.top == S.base
Status StackEmpty(SqStack S) {
if (S.top == S.base) {
return true;
} else {
return false;
}
}
//判满
Status FullEmpty(SqStack S) {
if (S.top - S.base == S.stacksize) {
return true;
} else {
return false;
}
}
//数制转换
void conversion(int N) {
SqStack S;
InitStack(S);
char e;
while (N) {
Push(S, N % 8);
N = N / 8;
}
while (!StackEmpty(S)) {
Pop(S, e);
printf("%d", e);
}
}
//括号匹配
Status Matching() {
SqStack S;
InitStack(S);
SElemType ch, x;
Status flag = 1;
printf("请输入需要匹配的括号(以#结束)：\n");
//char ch = getche();
scanf("%c", &ch);
while (ch != '#' && flag) {
switch (ch) {
case '(':
case '[':
Push(S, ch);
break;
case ')':
if (!StackEmpty(S) && GetTop(S) == '(') {
Pop(S, x);
} else {
flag = 0;
}
break;
case ']':
if (!StackEmpty(S) && GetTop(S) == '[') {
Pop(S, x);
} else {
flag = 0;
}
break;
}
//ch = getche();
scanf("%c", &ch);
}
if (StackEmpty(S) && flag) {
return true;
} else {
return false;
}
}
//功能菜单
Status choice() {
printf("==================================\n");
printf(" 顺序栈操作功能菜单 \n");
printf("1、进栈 2、出栈 3、获取栈顶元素 \n");
printf("4、清空 5、销毁 6、批量进栈 \n");
printf("7、打印栈内元素 8、数制转换 \n");
printf("9、括号匹配 10、判空 11、判满 \n");
printf("12、顺序栈的长度 13退出程序 \n");
printf("==================================\n");
return 0;
}
int main() {
SqStack Sqstack;
//初始化
Status rInitStack = InitStack(Sqstack);
if (rInitStack == OK) {
printf("顺序栈初始化成功！\n");
} else {
printf("顺序栈初始化失败！\n");
}
while (1) {
//功能菜单
choice();
int flag;
printf("请输入所需的功能编号：");
scanf("%d", &flag);
switch (flag) {
case 1: {//进栈
SElemType Pushdata;
printf("请输入插入元素(请在英文状态下输入例如:a): \n");
getchar();
scanf("%c", &Pushdata);
Status rPush = Push(Sqstack, Pushdata);
if (rPush == OK) {
printf("向顺序栈进栈%c成功！\n\n", Pushdata);
} else {
printf("向顺序栈进栈失败！\n\n");
}
}
break;
case 2: {//出栈
SElemType popData;
Status rPop = Pop(Sqstack, popData);
if (rPop == OK) {
printf("向顺序栈出栈%c成功！\n\n", popData);
} else {
printf("向顺序栈出栈失败！\n\n");
}
}
break;
case 3: {//获取栈顶元素
SElemType topData;
Status rTop = Top(Sqstack, topData);
if (rTop == OK) {
printf("向顺序栈获取栈顶元素：%c 。\n\n", topData);
} else {
printf("向顺序栈获取栈顶元素失败！\n\n");
}
//获取栈顶元素
// Status rGetTop = GetTop(Sqstack);
// if (rGetTop == OK) {
// printf("向顺序栈获取栈顶元素：%d\n", topData);
// } else {
// printf("向顺序栈获取栈顶元素失败！\n");
// }
}
break;
case 4: { //清空
Status rClearStack = ClearStack(Sqstack);
if (rClearStack == OK) {
printf("顺序栈清空成功！\n\n");
} else {
printf("顺序栈清空失败！\n\n");
}
}
break;
case 5: {//销毁
Status rDestroyStack = DestroyStack(Sqstack);
if (rDestroyStack == OK) {
printf("顺序栈销毁成功！\n\n");
} else {
printf("顺序栈销毁失败！\n\n");
}
}
break;
case 6: {//批量插入
int on;
printf("请输入想要插入的元素个数：\n");
scanf("%d", &on);
SElemType array[on];
for (int i = 1; i <= on; i++) {
getchar();
printf("向顺序栈第%d个位置插入元素为:", (i));
scanf("%c", &array[i]);
}
for (int i = 1; i <= on; i++) {
Status rPush = Push(Sqstack, array[i]);
if (rPush == OK) {
printf("向顺序栈第%d个位置插入元素%c成功！\n", i, array[i]);
} else {
printf("向顺序栈第%d个位置插入元素%c失败！\n", i, array[i]);
}
}
}
break;
case 7: {//打印栈内元素
printStack(Sqstack);
}
break;
case 8: {//数制转换
int N;
printf("请输入1个非负十进制数：");
scanf("%d", &N);
printf("十进制数：%d 。\n", N);
printf("转换为八进制数为:");
conversion(N);
printf("\n");
}
break;
case 9: {//括号匹配
Status rMatch = Matching();
if (rMatch == true) {
printf("括号匹配成功！\n\n");
} else {
printf("括号匹配不成功！\n\n");
}
}
break;
case 10: {//判空
Status rStackEmpty = StackEmpty(Sqstack);
if (rStackEmpty == true) {
printf("顺序栈为空栈！\n\n");
} else
printf("顺序栈不为空！\n\n");
}
break;
case 11: {//判满
Status rFullEmpty = FullEmpty(Sqstack);
if (rFullEmpty == true) {
printf("顺序栈已满！\n\n");
} else
printf("顺序栈不为满！\n\n");
}
break;
case 12: {//顺序栈的长度
Status length = StackLength(Sqstack);
printf("顺序栈的长度为：%d 。\n\n", length);
}
break;
case 13: {//退出程序
return 0;
}
break;
default: {
printf("输入错误，无此功能，请检查输入:\n\n");
}
}
}
return 1;
}
四、运行结果
