顺序栈的详解

已于 2023-10-20 20:05:52 修改
阅读量2.1k 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2023-10-19 23:44:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54938554/article/details/133875457
版权

一、栈的定义

1.1 栈的定义

栈是一种特殊的数据结构，它的特点是后进先出（Last In First Out，LIFO）。栈是一种线性结构，它可以用来存储一组具有相同类型的数据元素。栈的基本操作包括压入（push）和弹出（pop），其中压入操作将数据元素添加到栈的顶部，弹出操作将栈顶的数据元素移除并返回。

1.2 栈的特点

栈的特点包括：

  1. 后进先出：栈中最后一个添加的元素最先被弹出。

  2. 只能在栈顶进行操作：栈的操作只能在栈顶进行，不能在中间或底部操作，因为栈是一种先进后出的结构。

  3. 可以用数组或链表实现：栈可以用数组或链表来实现，数组实现的栈需要指定栈的大小，而链表实现的栈可以动态扩展。

  4. 存储空间受限：栈的存储空间是有限的，一旦达到栈的存储上限，就会出现栈溢出的问题。

  5. 可以用递归实现：栈也可以通过递归的方式来实现，每次递归函数调用都会将参数和返回地址压入栈中，直到递归结束，最后按照相反的顺序弹出栈中的元素。

二、栈的实现使用与应用

2.1 栈的接口定义

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);

2.2 栈的实现

2.2.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.2.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*/
}
2.2.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;
}
2.2.4  查找栈顶元素
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}

	*x = S->data[S->top];	/*栈顶元素赋值给x*/

	return 0;
}
2.2.5  判断栈是否为空
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}
2.2.6  判断栈是否已满
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}
2.2.7  销毁栈
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

2.3栈的应用

2.3.1十进制转二进制
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);
}
2.3.2后缀表达式计算
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);
			printf("%c\n",exp[i]);
			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 '-':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2- op1;
			push(&S, x);
			break;
		case '/':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2/op1;
			push(&S, x);
			break;	
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

2.4栈的使用

#include <stdio.h>
#include "seqstack.h"
#include "welcome.h"


int main(int argc, char* argv[])
{
	SeqStack S;
	DataType x;
	int maxsize;
	char yn;
	int i,m,n,cmd,d;
;
	for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<1000;m++)
			for(n=0;n<1000;n++)
			{
				;
			}
	}
	
		printf("---------顺序栈演示程序-----------\n");
	do
	{
		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:
			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
			fflush(stdin);
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!pop(&S, &x))
				{
					printf("栈顶元素【%d】已出栈！\n", x);
				}
			}

			break;
		case 4:
			if(!get_top(&S,&x)){
				printf("查找到栈顶元素[%d]\n",x); 
			}
			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(" 本程序为栈的演示程序，由黄彬森设计开发，程序完成了栈的基本功能！\n");		
		default:
			printf("输入选项不存在\n"); 		
		}

	}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);
			printf("%c\n",exp[i]);
			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 '-':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2- op1;
			push(&S, x);
			break;
		case '/':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2/op1;
			push(&S, x);
			break;	
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

三、完整代码

3.1  main.c文件代码

#include <stdio.h>
#include "seqstack.h"
#include "welcome.h"


int main(int argc, char* argv[])
{
	SeqStack S;
	DataType x;
	int maxsize;
	char yn;
	int i,m,n,cmd,d;
;
	for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<1000;m++)
			for(n=0;n<1000;n++)
			{
				;
			}
	}
	
		printf("---------顺序栈演示程序-----------\n");
	do
	{
		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:
			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
			fflush(stdin);
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!pop(&S, &x))
				{
					printf("栈顶元素【%d】已出栈！\n", x);
				}
			}

			break;
		case 4:
			if(!get_top(&S,&x)){
				printf("查找到栈顶元素[%d]\n",x); 
			}
			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(" 本程序为栈的演示程序，由黄彬森设计开发，程序完成了栈的基本功能！\n");		
		default:
			printf("输入选项不存在\n"); 		
		}

	}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);
			printf("%c\n",exp[i]);
			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 '-':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2- op1;
			push(&S, x);
			break;
		case '/':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2/op1;
			push(&S, x);
			break;	
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

3.2  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);

3.3  seqstack.c文件代码

#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;
}

3.4  welcome.h文件代码

char welcome[] = "\n\
|     .-.\n\ 
|    /   、         .-.\n\
|   /     、       /   、       .-.     .-.\n\
+--/-------、-----/-----、-----/---、---/---、---/-、-/-、/、/---\n\
| /         、   /       、   /     '-'     '-'              \n\
|/           '-'         '-'                               \n\
";

四、代码运行结果

|     .-.
|    /   、         .-.
|   /     、       /   、       .-.     .-.
+--/-------、-----/-----、-----/---、---/---、---/-、-/-、/、/---
| /         、   /       、   /     '-'     '-'
|/           '-'         '-'
---------顺序栈演示程序-----------
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：1
请输入栈的最大存储空间(MaxSize)：10
栈已初始化！
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：2
请输入入栈元素：x=10
元素【10】已入栈！
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：2
请输入入栈元素：x=30
元素【30】已入栈！
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：4
查找到栈顶元素[30]
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：5
栈内存在元素
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：6
栈未满
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：3
确定要出栈（出栈后数据不可恢复,y|n,n）？y
栈顶元素【30】已出栈！
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：7
栈已销毁
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：8
----------8.栈的应用------------
 1. 十进制转换为二进制
 2. 后缀表达式计算
 0. 返回
请选择：1
请输入一个十进制数：102
二进制为：1100110
----------8.栈的应用------------
 1. 十进制转换为二进制
 2. 后缀表达式计算
 0. 返回
请选择：2
请输入一个后缀表达式(eg. 56+):34+4-2*2/
3
4
4
2
2
计算结果为：34+4-2*2/ = 3
----------8.栈的应用------------
 1. 十进制转换为二进制
 2. 后缀表达式计算
 0. 返回
请选择：0
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：9
 本程序为栈的演示程序，由黄彬森设计开发，程序完成了栈的基本功能！
输入选项不存在
 1. 初始化
 2. 入栈
 3. 出栈
 4. 查找栈顶元素
 5. 判断栈为是否空
 6. 判断栈为是否满
 7. 销毁栈
 8. 栈的应用
 9. 帮助
请选择（0~9,0退出)：0

--------------------------------
Process exited after 128.2 seconds with return value 0
请按任意键继续. . .

五、小结

栈是一种特殊的顺序结构，栈存储方式以先入后出，后入先出的原则存储数据。入栈时添加元素会置于栈的栈顶，出栈时也需元素从栈顶处出栈，栈可以通过数组和链表实现，链表实现相对简单些，并且链表可以动态扩展,。

六、参考文献

【1】CSDN

【2】数据结构(C语言)

第十七天
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
顺序堆栈
LQS的博客
03-20 1188
堆栈示意图 堆栈进出原则 先进后出 数据集合 堆栈的数据集合的元素可以表示为任意的类类型。 操作集合 （1）入栈push(obj):把数据元素obj插入堆栈； （2）出栈pop():出栈，删除的数据元素由函数返回； （3）取栈顶元素getTop():取当前栈顶的数据元素并有函数返回； （4）notEmpty()：若栈非空则返回true,否则返回false. Stack接
顺序栈定义
10-13
### 顺序栈定义与实现详解 在数据结构与算法的学习中，栈是一种常见的线性数据结构，具有后进先出（LIFO）的特点。本文将深入解析“顺序栈”的概念、实现原理及其代码示例，旨在帮助读者理解并掌握顺序栈的内部机制...
已知入栈顺序，总结出栈顺序的规律
天射手座的博客
01-23 3万+
规律： 出栈的每一个元素的后面，其中比该元素先入栈的一定按照入栈逆顺序排列。 举例说明： 已知入栈顺序： 1 2 3 4 5 判断出栈顺序： 4 3 5 1 2 结果：不合理，原因是出栈元素3之后有 5 1 2 这三个元素，其中1 2 是比3先入栈的，根据规律，这两个出栈的顺序必须和入栈顺序相反，也就是 2 1 出栈，不可能按照1 2 顺序出栈。 已知入栈顺序： 1 2 3 4 5 判断出栈顺序：...
给定进栈顺序，判断一个序列是否为正确的出栈顺序
01-08
给定进栈顺序，判断一个序列是否为正确的出栈顺序
数据结构篇其四---栈：后进先出的魔法世界
最新发布
2303_79972050的博客
05-04 691
栈的学习难度非常简单，前提是如果你学过顺序表和单链表的话，我直接说我的观点了，栈就是有限制的顺序表和单链表。栈只允许一端进行插入删除。栈去除了各种情况复杂的插入删除，只允许一端插入删除的特性，这一种数据结构在实际应用场景非常有价值。
一个栈的入栈序列为ABCDEF，则不可能的出栈序列是
无鞋童鞋的博客
04-25 3万+
技术之瞳 阿里巴巴技术笔试心得习题2.65： 　　一个栈的入栈序列为ABCDEF，则不可能的出站序列是（D） 　　A、DEFCBA　　　　B、DCEFBA　　　　C、FEDCBA 　　D、FECDBA　　　　E、ABCDEF　　　　F、ADCBFE
栈的入栈和出栈的顺序规律
shadow_zed的博客
04-13 3万+
栈的入栈和出栈的顺序规律是先进后出，所以出栈的可能数目跟入栈的可能排列数目是一致的。a的出入有2中可能，b的出入有2种可能，c的出入有2种可能，d只需要关系入，只有一种可能。所以出栈方式数为2*2*2*1=8种。 1.出栈的每一个元素的后面，其中比该元素先入栈的一定按照入栈逆顺序排列。举例说明：已知入栈顺序：1 2 3 4 5判断出栈顺序：4 3 5 1 2，结果：不合理，原因是出栈元素3之后有 5 1 2 这三个元素，其中1 2 是比3先入栈的，根据规律，这两个出栈的顺序必须和入栈顺序相反，也就是 2
栈--顺序栈
zlz18225318697的博客
11-22 406
栈的概念： 栈是一种特殊的线性表，栈中的数据元素以及数据元素之间的逻辑关系和线性表相同，两者的区别在于：线性表的插入和删除操作可以在表的任意位置进行，而栈的插入和删除操作只允许在表的任意位置进行，而栈的插入和删除操作只允许在表的尾端进行。其中，栈中允许进行插入和删除操作的一端称为栈顶（top），另一端称为栈底（buttom）。通常，我们将栈的插入操作称为入栈（push）,而将删除操作称为出栈（po
LwIP协议栈源码详解_LwIP_协议栈详解_
09-29
**LwIP协议栈源码详解** LwIP（Lightweight TCP/IP）是一个开源的、轻量级的网络协议栈，适用于嵌入式系统。它由瑞典Chalmers大学的Adiscon公司开发，旨在为资源有限的微控制器提供TCP/IP功能。LwIP在设计时考虑了...
顺序栈 C++
05-09
顺序栈 C++ 实现详解 顺序栈是计算机科学中的一种基本数据结构，它是一种先进先出（First-In-First-Out，FIFO）的数据结构。下面我们将详细介绍顺序栈的 C++ 实现。 顺序栈的定义 顺序栈（Sequential Stack）是一...
C++描述的栈详解
10-06
本篇我们将深入探讨C++中栈的实现方式，特别是顺序栈（SeqStack）和栈链（LinkStack）。 首先，我们来看顺序栈的实现。顺序栈通常使用数组来存储元素，其操作包括入栈（Push）、出栈（Pop）、查看栈顶元素（GetTop...
LwIP协议栈的设计与实现-中文 与 LwIP协议栈源码详解
03-20
LwIP协议栈源码详解.pdf 和 LwIP协议栈的设计与实现_中文译稿.pdf 这两个文档很可能是深入分析LwIP源代码和设计原理的教程。它们可能涵盖了以下内容： 1. LwIP的架构和工作流程：详细解释各个模块的功能和交互方式...
Pop Sequence栈的顺序实现
weixin_42182906的博客
05-20 233
问题描述：Given a stack which can keep M numbers at most. Push N numbers in the order of 1, 2, 3, ..., N and pop randomly. You are supposed to tell if a given sequence of numbers is a possible pop sequence...
入栈出栈规律·
热门推荐
u014424628的专栏
11-08 4万+
相信大家都做过类似这样的题目： 已知入栈序列为：1 2 3 4 5，这5个数一次入栈，出栈顺序、时机任意。 则下列可能的出栈序列不正确的是（） A 1 2 3 4 5 B 3 2 1 5 4 C 1 5 4 3 2 D 4 3 5 1 2这种题目，相信给你一分钟心算一下就可以出来了。然而，当规模增加到10个数，20个数，估计你话费的时间会成指数增长。但是我现在想在10秒之内做出来，不管是
CIL之——入栈和出栈顺序
xiaouncle的博客
06-03 923
或许大家都听说过，栈是先进后出，队列是先进先出，那实际中入栈和出栈是怎么进行的呢？下面让我们一窥究竟吧！
【练习】入栈出栈规则
本末实验室
07-17 9805
问：已知元素的入栈顺序为abcde，则下列哪种出栈顺序是不可能的(出栈和入栈操作可交叉进行） A．edcba B．cabde C．dcbae D．bcdea 思路一 分析：出栈和入栈操作可交叉进行，说明入栈操作并不一定是连续进行的。由于栈有后入先出的逻辑特点，所以对于该题有如下规律 出栈的第一个元素是在原来的次序中是第几个，那么他的前面的元素必然都还在栈中。 比如c先出...
N个数依次入栈，出栈顺序有多少种
weixin_34194551的博客
01-08 216
题目：N个数依次入栈，出栈顺序有多少种？ 首先介绍一下卡特兰数：卡特兰数前几项为 : 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190, 6564120420, 2446626702...
顺序栈，栈篇（画图教您顺序栈的进栈出栈操作）
qq_46104786的博客
11-01 9022
数据结构专升本学习，栈篇（顺序栈） 前言： 上次我们学了，线性表里面的的链表，今天我们学栈，用官方的术语就是，栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）也就是后进先出（LIFO）或者先进后出。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。 每日一遍，快乐无极限，哈哈哈 1.什么是栈 我们先学习一下栈的逻辑，在编程中逻辑是非常重要的东
元素出栈、入栈顺序的合法性
step_ma的博客
07-20 1503
元素出栈、入栈顺序的合法性 元素出栈、入栈顺序的合法性。如：入栈的序列（1,2,3,4,5），出栈序列为（4,5,3,2,1），则合法。入栈的序列（1,2,3,4,5），出栈序列为（4,5,2,3,1），则不合法。 算法思想： 建立一个辅助栈，把输入的第一个序列中的数字依次压入该辅助栈中，并按照第二个序列依次从该栈弹出数字。 入栈的序列（1,2,3,4,5），出栈序列为（4,5,3,2,1
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值