详解顺序栈

已于 2023-10-20 20:38:58 修改
阅读量653 收藏 3
点赞数 1
文章标签： 数据结构 开发语言 c语言
于 2023-10-19 23:25:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51771262/article/details/133935266
版权

定义

顺序栈是一种基于数组实现的栈数据结构，它遵循栈的基本原则，即“后进先出”。顺序栈的定义包括以下要点：

  1. 数据存储结构：顺序栈内部使用数组来存储数据元素。通常，这个数组有固定的大小，当栈满时无法再添加元素，或者可以使用动态数组来实现动态调整大小的栈。

  2. 栈顶指针：顺序栈中有一个指向栈顶元素的指针，通常以整数表示，初始时可以是-1，表示栈为空。当有元素入栈时，栈顶指针会递增，指向新的栈顶元素。

特点

  1. 基于数组实现：顺序栈内部使用数组来存储数据元素，这使得它在内存中以一段连续的存储空间表示。这也意味着在创建顺序栈时需要预先分配一定大小的内存空间，因此顺序栈的大小是固定的，无法动态调整。

  2. 后进先出（LIFO）：顺序栈遵循栈的基本原则，即后进入栈的元素会先被弹出，反之亦然。这是栈数据结构的核心特点。

  3. 栈顶指针：顺序栈中维护一个栈顶指针，该指针指向当前栈顶元素的位置。栈顶指针通常初始化为-1，表示栈为空。当有元素入栈时，栈顶指针递增，当元素出栈时，栈顶指针递减。

  4. 固定大小：顺序栈的大小是固定的，因此在创建栈时需要指定栈的最大容量。当栈满时，无法再添加元素，这可能导致栈溢出问题。要解决这个问题，可以使用动态数组来实现动态调整大小的栈。

  5. 高效的操作：由于基于数组的存储结构，顺序栈的操作效率通常很高。入栈和出栈操作都是常数时间复杂度（O(1)）的操作。获取栈顶元素也是O(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;
}

入栈 

这段代码的作用是将数据元素 x 入栈到顺序栈中。它会先检查栈是否已满，如果栈未满，就将栈顶指针移动，然后将数据放入栈中。如果栈已满或其他错误发生，函数会返回相应的错误代码。

int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}

	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}

出栈 

这段代码的作用是执行出栈操作，它首先检查栈是否为空，如果栈非空，将栈顶元素的值赋给指定的变量X，然后移动栈顶指针，将元素从栈中移除。如果栈为空或其他错误发生，函数会返回相应的错误代码。

int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}

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

	return 0;
}

 取顶栈元素

这段代码的作用是获取顺序栈的栈顶元素，它首先检查栈是否为空，如果栈非空，将栈顶元素的值赋给指定的变量X。如果栈为空或其他错误发生，函数会返回相应的错误代码。

int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}

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

	return 0;
}

判空 

这段代码通过检查栈顶指针是否等于-1来确定栈是否为空。因为栈顶指针初始化为-1，当没有元素入栈时，它保持为-1。如果栈为空，函数返回1，否则返回0。

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

判满

这段代码的作用是比较栈顶指针和栈的最大容量来检查栈是否已满。如果栈顶指针等于 S->maxsize - 1，说明栈中已经存满了数据元素，因为栈顶指针从0开始计数。如果栈已满，函数返回1，否则返回0。

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

销毁

这段代码的作用是释放顺序栈的内存空间，以避免内存泄漏。在销毁栈之前，它会释放存储栈元素的数组的内存。

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

栈的应用

十进制转换二进制

这段代码声明了一个名为S的顺序栈结构。然后通过init 函数初始化栈S，分配了32个元素的存储空间。这个栈将用于存储二进制表示中的每一位。随后的循环用于将十进制数转换为二进制。在每次循环迭代中，它计算d除以2的余数，将余数入栈，然后将d除以2，以准备下一次迭代。这个过程将重复，直到d不再大于0。接下来的while(!empty(&S))循环用于出栈操作并输出每位的二进制数。它依次从栈中弹出元素，将它们存储在变量b中，然后通过printf函数输出这个二进制位。最后，通过  destroy(&S)函数销毁栈，释放内存资源

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

后缀表达式计算

这段代码先声明了一个名为 S 的顺序栈结构。再声明几个整数变量，用于在计算过程中存储操作数和结果。char exp[20]这是一个字符数组，用于存储输入的后缀表达式。init(&S, 10)通过 init 函数初始化栈 S，分配了10个元素的存储空间。接下来读取输入的后缀表达式，并将其存储在字符数组exp中。for(i=0; i<strlen(exp); i++)用于迭代处理后缀表达式的每个字符。再使用 switch 语句来根据字符的不同执行不同的操作。

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

完整代码

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("-------------本程序由闫佳乐开发-----------，\n------------------如有疑问，欢迎打扰------------\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);
			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;
}

运行效果截图

 

 

 

 

 

小结 

顺序栈是一种基于数组实现的线性数据结构，它遵循后进先出（LIFO）的原则，即最后入栈的元素最先出栈。

关键概念： 

栈：栈是一种限定仅在表尾进行插入（入栈）或删除（出栈）操作的线性数据结构。

顺序栈：顺序栈是通过数组实现的栈，使用数组作为底层存储结构。它的特点是可以通过下标访问元素，具有固定的容量。

入栈：将元素插入栈顶的操作称为入栈。

出栈：从栈顶移除元素的操作称为出栈。

顺序栈的特点：

固定容量：顺序栈具有固定的最大容量，不能动态扩展。一旦达到最大容量，再次入栈会导致栈溢出。

随机访问：由于使用数组实现，可以通过下标随机访问栈中的元素。

高效入栈和出栈：由于栈顶的元素是最后一个入栈的元素，入栈和出栈操作非常高效。

应用广泛：顺序栈在计算机科学和编程中有广泛的应用，包括函数调用、表达式求值、内存管理、算法和数据结构实现等领域。

参考文献

栈结构之顺序栈详解（C语言版）_顺序栈的定义-CSDN博客

【精选】(全网最细）顺序栈详解 ＋实例解析-CSDN博客

C语言实现顺序栈的创建和操作(进栈，出栈，打印等等）_编写进栈、出栈、显示栈中全部元素的程序-CSDN博客

 相关参考课程——《中国大学慕课-22考研计算机王道数据结构》《bilibili-数据结构 标准c语言实现》

祖国人在吉祥村用镭射眼打姨
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
顺序栈 C++
05-09
顺序栈 C++ 实现详解 顺序栈是计算机科学中的一种基本数据结构，它是一种先进先出（First-In-First-Out，FIFO）的数据结构。下面我们将详细介绍顺序栈的 C++ 实现。 顺序栈的定义 顺序栈（Sequential Stack）是一...
数据结构——顺序栈
2301_77179941的博客
05-08 6910
栈（stack）又名堆栈，它是一种运算受限的线性表，要严格遵循先进后出的原理。
顺序栈的基本操作（超详细）
热门推荐
m0_53679998的博客
06-08 3万+
本文是在b站上学完王卓老师之后写的，各种操作我都觉得都十分的详细。如果代码或者描述有不对的地方，欢迎大家指正。
(全网最细）顺序栈详解 ＋实例解析
qq_45288176的博客
05-27 3481
目录 一：栈的介绍 1：什么是栈（Stack）？ 2：栈的特点 3：栈的相关概念 1：基本概念 2：基本操作和图示(如图为顺序栈实例) 4：栈的应用 三：栈的表示和操作实现 1：栈的抽象数据结构类型的定义 2：主要函数介绍 3.1顺序栈的表示和操作 1：了解顺序栈 2：特殊标志：栈空和栈满 3：栈的数据类型定义和操作 一：栈的介绍 1：什么是栈（Stack）？ 栈是一种常用的、重要的数据结构栈是一种限定插入和删除只能在表的 "端点”进行的线性表，此端点就在队.
数据结构-顺序栈详解（C语言）
m0_55698213的博客
10-20 1824
本文主要讲述顺序栈基本定义和特点以及顺序栈的C语言代码实现与顺序栈的实际应用。以上就是顺序栈的基本介绍，本文仅仅简单介绍了顺序栈概念、特点、运算以及顺序栈的应用。顺序栈是一种特殊的线性数据结构，它遵循先进后出（FILO）的原则，即在栈顶添加和删除元素。顺序栈在计算机科学中经常使用，因为它允许我们在高频率的情况下进行添加和删除操作。
栈结构之顺序栈详解（C语言版）
qq_44075108的博客
10-24 1万+
本文对栈结构的顺序栈进行详解并使用C语言对顺序栈进行实现，文章的主要内容包括顺序栈的定义、顺序栈的结构以及顺序栈的常用操作
LwIP协议栈源码详解_LwIP_协议栈详解_
09-29
**LwIP协议栈源码详解** LwIP（Lightweight TCP/IP）是一个开源的、轻量级的网络协议栈，适用于嵌入式系统。它由瑞典Chalmers大学的Adiscon公司开发，旨在为资源有限的微控制器提供TCP/IP功能。LwIP在设计时考虑了...
栈的四则运算实现及详解
05-15
c语言数据结构栈的四则运算（带括号）的实现，里面有解释
LwIP协议栈的设计与实现-中文 与 LwIP协议栈源码详解
最新发布
03-20
LwIP协议栈源码详解.pdf 和 LwIP协议栈的设计与实现_中文译稿.pdf 这两个文档很可能是深入分析LwIP源代码和设计原理的教程。它们可能涵盖了以下内容： 1. LwIP的架构和工作流程：详细解释各个模块的功能和交互方式...
栈和队列详解
06-17
"栈和队列详解" 栈和队列是数据结构中两个基本的数据结构概念，本文将详细介绍栈和队列的定义、原理、操作和应用。 栈的定义和原理 栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构，栈中的元素按照加入...
顺序栈的讲解
m0_56992713的博客
10-24 9206
堆栈（简称栈）是插入和删除操作都在表的同一端进行的线性表。运行插入和删除元素的一端称为栈顶（top），另一端称为栈底（bottom）。如果堆栈中没有元素，则为空栈。栈是一个后进后出的结构（Last In First Out），简称为LIFO结构。 有几点需要注意： 1.栈本质上还是线性表，只是这个线性表增加了新的限定规则，只能在一端进行插入和删除。 2.栈和线性表一样，也有顺序存储（顺序栈）和链式存储（链式栈）两种结构。 3.栈的插入叫进栈，栈的删除叫出栈 目录顺序栈初始化出栈入栈判断栈空判断栈满取栈顶.
栈详解（顺序栈和链栈）
o8699458的博客
08-08 1446
栈什么是栈？顺序栈链栈 什么是栈？ 栈是一种基本数据结构，因其拥有后进先出的特点（Last in First out），也就是LIFO，栈的一种常见用途就是用来判断一串字符中的括号是否有效。 括号的类型有{}、[]、()，“{[]}”像这样的就是有效的，而像"{[])"这样的就是无效的括号，这通常用于编译器的语法检查。 在内存的中使用也是一种栈，因函数调用会压栈，每调用一次压栈一次，当递归层次太深时，我们经常看到编译器报错：“Stack Overflow”,也就是栈溢出。 栈的主要操作有Push和Pop，入
数据结构-顺序栈
2301_79870182的博客
10-19 258
在了解顺序站之前先了解什么是栈栈的概念：1、栈：一种只允许在一端进行插入或删除的线性表2、栈顶：线性表允许进行插入删除的那一端3、栈底：固定的，不允许进行插入和删除的那一端4、空栈：不含任何元素的空表栈了解完了我们在了解顺序栈顺序栈的定义顺序栈是栈的顺序实现。顺序栈是指利用顺序存储结构实现的栈。采用地址连续的存储空间（数组)依次存储栈中数据元素，由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处；
数据结构——栈（顺序栈）
qq_39628738的博客
03-11 3479
栈的概念：只能在表尾进行插入（入栈）和删除（出栈）的数据结构（受到限制的线性表）。 表尾比较特殊，我们一般把这个表尾叫做栈顶，另一端栈底。没有数据节点，则叫做空栈 特点：先进后出（FILO）a1最先进栈，a1最后出栈。 为了更好的理解，可以想象生活中的例子：子弹弹夹 直接给出栈的结构体定义：（结构体中需要三个成员） #define INIT_SIZE 10 typedef int ELEM_TYPE; typedef struct Stack { ELEM_TYPE* base;//一个
顺序栈（栈的顺序储存结构）
q322359的博客
09-13 1187
顺序栈（栈的顺序储存结构）
C语言数据结构之顺序栈
m0_58303983的博客
10-21 657
顺序栈是栈的顺序实现，它利用顺序存储结构，即采用地址连续的存储空间（数组）依次存储栈中数据元素。由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处。栈顶位置是随入栈和出栈操作而变化的，故需用一个整型变量top来记录当前栈顶元素在数组中的位置。您的辛勤付出和无私奉献，让我感到非常敬佩和感激。我将永远铭记您的教诲，不断努力学习，成为一个对社会有用的人。不适用于大量数据的排序。
数据结构——顺序栈详解
weixin_51785373的博客
10-20 1823
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
数据结构3栈和队列.pdf
01-14
该资源是关于数据结构中的栈和队列的讲解，主要涵盖了栈的基本概念、顺序栈和链栈的实现以及队列的类型，包括循环队列、链式队列和双端队列。此外，还提到了数组，特别是多维数组的压缩矩阵和稀疏矩阵。 在数据结构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值