详解顺序栈

最新推荐文章于 2024-05-30 19:34:38 发布

m0_72158882

最新推荐文章于 2024-05-30 19:34:38 发布

阅读量51

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/m0_72158882/article/details/133994751

版权

定义

顺序栈是一种特殊的线性表，它只允许在表的一端进行插入和删除操作，通常被称为"后进先出"（Last In First Out，LIFO）的线性表。顺序栈在插入和删除操作时，需要保持其逻辑关系，即后插入的元素先被删除。

顺序栈的定义通常包括以下几个部分：

栈顶指针：一个指示栈顶元素位置的指针。当栈为空时，栈顶指针通常指向数组的第一个元素（或者最后一个元素，视具体实现而定）。
栈底指针：一个指示栈底元素位置的指针。当栈为空时，栈底指针通常指向数组的最后一个元素（或者第一个元素，视具体实现而定）。
插入操作：向栈顶添加一个新元素。这通常需要将新元素放在栈顶指针所指向的位置，然后更新栈顶指针。
删除操作：从栈顶删除一个元素。这通常需要将栈顶指针向后移动一位（除非栈只有一个元素），然后返回被删除的元素。

特点

后进先出（LIFO）：顺序栈遵循后进先出的原则，即最后插入的元素会先被删除。这使得顺序栈在需要优先处理最新数据的情况下非常有用。
连续存储空间：顺序栈使用连续的存储空间来存储元素，通常使用数组来实现。这使得插入和删除操作更加高效，因为它们可以直接通过数组索引来访问元素。
栈顶操作：顺序栈只允许在栈顶进行插入和删除操作。这使得操作更加简单和高效，因为只需要维护一个指向栈顶的指针。
动态增长和收缩：顺序栈可以根据需要动态增长和收缩。当栈满时，可以分配更多的存储空间；当栈空时，可以回收未使用的空间。这使得顺序栈能够有效地利用内存资源。
有序性：顺序栈中的元素是有序的，即后插入的元素会放在先插入元素的后面。这使得顺序栈可以用于实现一些需要有序数据结构的应用，如深度优先搜索等。
高效插入和删除：顺序栈的插入和删除操作可以在O(1)的时间复杂度内完成。这使得顺序栈在需要频繁插入和删除操作的情况下非常高效。
适用于多种应用场景：顺序栈可以用于实现多种不同的算法和数据操作，如表达式求值、函数调用栈、深度优先搜索等。这使得顺序栈在计算机科学中具有广泛的应用价值。

顺序栈的实现

1.初始化

int init(SeqStack *S, int MaxSize)
{
	/*申请内存空间*/
	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
 
	if(!S->data)
	{
		printf("内存申请错误，初始化失败！[10001]\n");
		return 10001;
	}
	S->maxsize = MaxSize;
	S->top = -1;
	return 0;
 }

2.入栈


int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}
 
	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}

3.出栈

int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	
 
	return 0;
 }

4.取顶栈元素


int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
 
	return 0;

 }

5.判断栈是否为空


int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}

6.判断栈是否为满


int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}

7.销毁

int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

完整代码

main.c


#include <stdio.h>
#include <string.h>
 
#include "seqstack.h"
 
/*十进制转换为二进制*/
int d_to_b(int d);
 
/*后缀表达式计算*/
int expression();
 
int main(int argc, char* argv[])
{
	SeqStack S;
 
	int cmd;
	int d;
 
	DataType x;
	int maxsize;
	char yn;
 
	
	do
	{
		printf("---------顺序栈演示程序-----------\n");
		printf(" 1. 初始化\n");
		printf(" 2. 入栈\n");
		printf(" 3. 出栈\n");
		printf(" 4. 取栈顶元素\n");
		printf(" 5. 栈是否空？\n");
		printf(" 6. 栈是否满？\n");
		printf(" 7. 销毁栈\n");
		printf(" 8. 栈的应用\n");
        printf(" 9. 帮助\n");
		printf("请选择（0~9,0退出)：");
		scanf("%d", &cmd);
		switch(cmd)
		{
		case 1:
			printf("请输入栈的最大存储空间(MaxSize)：");
			scanf("%d", &maxsize);
			if(!init(&S, maxsize))
			{
				printf("栈已初始化！\n");
			}
			break;
		case 2:
			printf("请输入入栈元素：x=");
			scanf("%d", &x);
			if(!push(&S, x))
			{
				printf("元素【%d】已入栈！\n", x);
 
			}
			break;
		case 3:
            getchar();
			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!pop(&S, &x))
				{
					printf("栈顶元素【%d】已出栈！\n", x);
				}
			}
			break;
            case 4:
                DataType topElement;//存储从栈中获取的顶部元素
                int result = get_top(&S, &topElement);//用于存储 get_top 函数的返回值
                //&S 是一个指向栈的指针，&topElement 是一个指向 topElement 变量的指针。
                if (result == 0) {
                    printf("栈顶元素为【%d】;\n", topElement);
                } else {
                    printf("获取栈顶元素失败，错误代码：%d\n", result);
                }//如果 result 等于 0，表示获取栈顶元素成功，将栈顶元素的值打印到屏幕上，
                // 否则打印获取栈顶元素失败的错误消息以及错误代码。
                break;
 
            case 5:
                if (empty(&S)) {
                    printf("栈为空！\n");
                } else {
                    printf("栈不为空！\n");
                }
                break;
 
            case 6:
                if (full(&S)) {
                    printf("栈已满！\n");
                } else {
                    printf("栈未满！\n");
                }
                break;
 
            case 7:
                destroy(&S);
                printf("栈已销毁！\n");
                break;
		case 8:
			do
			{
				printf("----------8.栈的应用------------\n");
				printf(" 1. 十进制转换为二进制\n");
				printf(" 2. 后缀表达式计算\n");			
				printf(" 0. 返回\n");
				printf("请选择：");
				scanf("%d", &cmd);
 
				if(cmd == 1)
				{
					printf("请输入一个十进制数：");
					scanf("%d", &d);
					printf("二进制为：");
					d_to_b(d);
					printf("\n");
				}
 
				if(cmd == 2)
				{
					expression();
				}
			}while(cmd!=0);
			cmd = -1;
			break;
 
            case 9:
                printf("_本程序有叶永豪开发 如有问题欢迎交流_");
		}
 
 
	}while(cmd!=0);
 
	return 0;
}
 
 
/*十进制转换为二进制*/
int d_to_b(int d)
{
	SeqStack S;
	int b;
 
	/*初始化栈*/
	init(&S,32);
 
	/*d不为0，余数进栈*/
	while(d)
	{
		push(&S, d % 2);
		d /= 2;
	}
	
	/*依次出栈*/
	while(!empty(&S))
	{
		pop(&S,&b);
		printf("%d", b);
	}
 
	/*销毁栈*/
	destroy(&S);
}
 
 
/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int x;
 
	char exp[20]; /*后缀表达式*/
 
	init(&S, 10);
 
	printf("请输入一个后缀表达式(eg. 56+):");
	scanf("%s", exp);
 
	for(i=0;i<strlen(exp);i++)
	{
		switch(exp[i])
		{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			/*入栈*/
			push(&S, exp[i]-48);
			break;
		case '+':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 + op2;
			push(&S, x);
			break;
 
		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			push(&S, x);
            break;
 
            case '-':
                /* 出2个 */
                pop(&S, &op1);
                pop(&S, &op2);
                x = op2 - op1;
                push(&S, x);
                break;
 
            case '/':
                /* 出2个 */
                pop(&S, &op1);
                pop(&S, &op2);
                if (op1 == 0)
                {
                    printf("错误：除数为0\n");
                    destroy(&S);
                    return 0;
                }
                x = op2 / op1;
                push(&S, x);
                break;
 
 
 
		}
 
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
 }

seqstack.h


/*
	seqstack.h
	顺序栈
*/
 
typedef int DataType;
 
 
typedef struct
{
	DataType *data; /* 堆空间 */
	int maxsize;
	int top;		/* 栈顶指针 */
}SeqStack;
 
 
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize);
 
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x);
 
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x);
 
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x);
 
/* 5. 栈为空？*/
int empty(SeqStack *S);
 
/* 6. 栈满？*/
int full(SeqStack *S);
 
/* 7. 销毁*/
int destroy(SeqStack *S);

seqstack.c


/*
	seqstack.c
*/
#include <stdio.h>
#include <malloc.h>
#include "seqstack.h"
 
 
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
	/*申请内存空间*/
	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
 
	if(!S->data)
	{
		printf("内存申请错误，初始化失败！[10001]\n");
		return 10001;
	}
	S->maxsize = MaxSize;
	S->top = -1;
	return 0;
}
 
 
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}
 
	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}
 
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	
 
	return 0;
}
 
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
 
	return 0;
}
 
/* 5. 栈为空？*/
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}
 
/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}
 
 
/* 7. 销毁*/
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

运行效果截图

小结

顺序栈的实现可以使用数组来实现，通过维护一个栈顶指针来指示栈顶元素的位置。顺序栈的插入和删除操作都是在栈顶进行的，插入操作将新元素放在栈顶指针所指向的位置，并将栈顶指针向后移动一位；删除操作将栈顶指针向后移动一位，并返回被删除的元素。如果栈已满，插入操作需要重新分配更多的存储空间；如果栈为空，删除操作需要特殊处理。顺序栈还可以通过动态分配内存来实现动态增长和收缩。在实现顺序栈时，需要考虑到其特点，如后进先出的原则、连续存储空间、栈顶操作等。

m0_72158882

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
详解顺序栈

顺序栈是一种特殊的线性表，它只允许在表的一端进行插入和删除操作，通常被称为"后进先出"（Last In First Out，LIFO）的线性表。顺序栈在插入和删除操作时，需要保持其逻辑关系，即后插入的元素先被删除。
复制链接

扫一扫