数据结构作业之栈

已于 2022-05-10 22:39:29 修改
阅读量357 收藏
点赞数 1
文章标签： 数据结构 c语言
于 2022-05-10 22:26:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/greatwaves11/article/details/124698139
版权

栈的定义

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

基础栈

一，结构体和宏

#include <stdio.h>
#include <malloc.h>

#define STACK_MAX_SIZE 10

/*
 * 线性整型堆栈。 
 */
typedef struct CharStack{
 	int top;
 	
 	int data[STACK_MAX_SIZE];
 } *CharStackPtr;

二，输出栈

/*
 * 输出栈 
 */
void outputStack(CharStackPtr paraStack){
	for(int i = 0; i<= paraStack->top; i++){
 		printf("%c ", paraStack->data[i]);	
	}
	printf("\r\n");
}

三，初始化空栈

/*
 * 初始化一个空栈  
 */
CharStackPtr charStackInit(){
	CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(CharStackPtr));
	resultPtr->top = -1;
	
	return resultPtr;  
}

四，将数据压入，出栈

/*
 * 把一个元素插入栈中  
 * @param paraValue 被插入的元素 
 */
void push(CharStackPtr paraStackPtr, int paraValue){
	// Step 1. 检查空间
	if(paraStackPtr->top >= STACK_MAX_SIZE - 1){
		printf("Cannot push element: stack full.\r\n");
		return;
	}
	
	// Step 2. 更新栈top数据
	paraStackPtr->top++;
	
	// Step 3. 插入元素
	paraStackPtr->data[paraStackPtr->top] = paraValue; 
}

/*
 * 把一个元素从栈中删除  
 * @return 被删除的数据 
 */
char pop(CharStackPtr paraStackPtr){
	// Step 1. 检查空间
	if(paraStackPtr->top < 0){
		printf("Cannot pop element: stack empty.\r\n");
		return '\0';
	}
	
	// Step 2. 更新栈top数据
	paraStackPtr->top--;
	
	// Step 3. 删除元素
	return paraStackPtr->data[paraStackPtr->top+1]; 
}

五，功能测试和程序入口

/*
 * 功能测试 
 */
void pushPopTest(){
	printf("---- pushPopTest begins. ----\r\n");
	
	// 初始化
	CharStackPtr tempStack = charStackInit();
	printf("After initialization, the stack is: ");
	outputStack(tempStack);
	
	// 栈的插入
	for( char ch = 'a'; ch < 'm'; ch++){
		printf("Pushing %c.\r\n", ch);
		push(tempStack, ch);
		outputStack(tempStack);
	}
			
	// 栈的删除
	for( int i = 0; i < 3; i ++){
		char ch = pop(tempStack);
		printf("Pop %c.\r\n", ch);
		outputStack(tempStack);
	}  
	
	printf("---- pushPopTest ends. ----\r\n");
} 
/*
 * 程序入口 
 */
int main(){
	pushPopTest();
	return 0;
}

六，输出结果

---- pushPopTest begins. ----
After initialization, the stack is: 
Pushing a.
a
Pushing b.
a b
Pushing c.
a b c
Pushing d.
a b c d
Pushing e.
a b c d e
Pushing f.
a b c d e f
Pushing g.
a b c d e f g
Pushing h.
a b c d e f g h
Pushing i.
a b c d e f g h i
Pushing j.
a b c d e f g h i j
Pushing k.
Cannot push element: stack full.
a b c d e f g h i j
Pushing l.
Cannot push element: stack full.
a b c d e f g h i j
Pop j.
a b c d e f g h i
Pop i.
a b c d e f g h
Pop h.
a b c d e f g
---- pushPopTest ends. ----

栈的应用之括号匹配

一，在普通栈的基础上加入判断括号的函数

bool bracketMatching(char* paraString, int paraLength){
	// Step 1. 初始化栈，将'#'放在栈的底部
	CharStackPtr tempStack = charStackInit();
	push(tempStack, '#');
	char tempChar, tempPopedChar;
	
	// Step 2.  顺序判断
	for(int i = 0;i < paraLength; i++){
		tempChar = paraString[i];
		
		switch(tempChar){
			case'(':
			case'[':
			case'{':
				push(tempStack, tempChar);
				break;
			case')':
				tempPopedChar = pop(tempStack);
				if(tempPopedChar != '('){
					return false;
				}
                break;
			case']':
				tempPopedChar = pop(tempStack);
				if(tempPopedChar != '['){
					return false;
				}
                break;
			case'}':
				tempPopedChar = pop(tempStack);
				if(tempPopedChar != '{'){
					return false;
				}
                break;
			default:
				break;
		}
	} 
    tempPopedChar = pop(tempStack);
	if(tempPopedChar != '#'){
		return false;
	}
	return true;
} 

/*
 * 功能测试
 */
void bracketMatchingTest() {
	char* tempExpression = "[2 + (1 - 3)] * 4";
	bool tempMatch = bracketMatching(tempExpression, 17);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);


	tempExpression = "( )  )";
	tempMatch = bracketMatching(tempExpression, 6);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);

	tempExpression = "()()(())";
	tempMatch = bracketMatching(tempExpression, 8);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);

	tempExpression = "({}[])";
	tempMatch = bracketMatching(tempExpression, 6);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);


	tempExpression = ")(";
	tempMatch = bracketMatching(tempExpression, 2);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);
}

/*
 * 程序入口 
 */
int main(){
	bracketMatchingTest();
	return 0;
}

 此处要注意老师代码的149行是要改成return false,否则特殊情况会出错。

二，输出结果

Is the expression '[2 + (1 - 3)] * 4' bracket matching? 1 
Is the expression '( )  )' bracket matching? 0 
Is the expression '()()(())' bracket matching? 1
Is the expression '({}[])' bracket matching? 1
Is the expression ')(' bracket matching? 0

栈的应用之表达式求值

#include <iostream>
#include <cstring>
#include <algorithm>
#include <stack>
#include <unordered_map>//优先级判断的头文件

using namespace std;

stack<int> num;//创建储存num的栈
stack<char> op;//创建储存符号的栈

void eval()
{
    auto b = num.top();
    num.pop();
    auto a = num.top();
    num.pop();
    auto c = op.top();
    op.pop();
    int x;
    if (c == '+') x = a + b;
    else if (c == '-') x = a - b;
    else if (c == '*') x = a * b;
    else x = a / b;//因为是先pop的b，所以此处是a/b
    num.push(x);
}

int main()
{
    unordered_map<char, int> pr{{'+', 1}, {'-', 1}, {'*', 2}, {'/', 2}};//用于优先级的判断
    string str;
    cin >> str;
    for (int i = 0; i < str.size(); i ++ )
    {
        auto c = str[i];
        if (isdigit(c))//isdigit判断c是否是十进制数
        {
            int x = 0, j = i;
            while (j < str.size() && isdigit(str[j]))
                x = x * 10 + str[j ++ ] - '0';//将多位数字和为int数据存储
            i = j - 1;
            num.push(x);
        }
        else if (c == '(') op.push(c);
        else if (c == ')')
        {
            while (op.top() != '(') eval();//在遇到左括号之前进行从后往前的运算
            op.pop();
        }
        else
        {
            while (op.size() && op.top() != '(' && pr[op.top()] >= pr[c]) eval();//优先级判断先进行哪种计算
            op.push(c);
        }
    }
    while (op.size()) eval();//如果括号外还有数字，继续进行计算
    cout << num.top() << endl;
    return 0;
}

在学长的代码基础上进行了进一步的讲解与理解，通过c++来写表达式求解可以更加简洁，但是本版本代码还有一些问题，比如不能计算更加复杂的函数以及不能判断输入的表达式是否正确。

模仿着写的c代码

#include <stdio.h>
#include <malloc.h>
#include <string.h>
int a[21],b[21],x,num1,num2,len,c[10]={0,0,2,1,0,1,0,2};
void eval(int o)
{
	o=b[o];
	int i,j,k;
	k=0;
	i=a[num1];
	num1--;
	j=a[num1];
	num1--;
	if(o==2)
	{
		k=i*j;
	}
	if(o==3)
	{
		k=i+j;
	}
	if(o==5)
	{
		k=j-i;
	}
	if(o==7)
	{
		k=j/i;
	}
	num1++;
	a[num1]=k;
}
void Test(char* str)
{
	int i,j,k;
	num1=0;num2=0;
	len=(int)strlen(str);
	for(i=0;i<len;i++)
	{
		if(str[i]<='9'&&str[i]>='0')
		{
			x=0;
			j=i;
			num1++;
			while(str[j]<='9'&&str[j]>='0'&&j<len)
			{
				x=x*10+str[j]-'0';
				j++;
			}
			a[num1]=x;
			i=j-1;
		}
		else if(str[i]=='(')
		{
			num2++;
			b[num2]='('-40;
		}
		else if(str[i]==')')
		{
			while(b[num2]!=0)
			{
				eval(num2);
				num2--;
			}
			num2--;
		}
		else
		{
			while(c[b[num2]]>=c[str[i]-40]&&b[num2]!=0)
			{
				eval(num2);
				num2--;
			}
			num2++;
			b[num2]=str[i]-40;
		}
	}
	while(num2!=0)
	{
		eval(num2);
		num2--;
	}
	printf("%d\n",a[1]);
}
int main()
{
	char* str1 = "(0+72)/9+1";
    char* str2 = "2+(2+3)/5+1*9";
    Test(str1);
    Test(str2);
    return 0;
}

测试结果：

9
12

完整代码

#include <stdio.h>
#include <malloc.h>

#define STACK_MAX_SIZE 10

/*
 * 线性整型堆栈。 
 */
typedef struct CharStack{
 	int top;
 	
 	int data[STACK_MAX_SIZE];
 } *CharStackPtr;

/*
 * 输出栈 
 */
void outputStack(CharStackPtr paraStack){
	for(int i = 0; i<= paraStack->top; i++){
 		printf("%c ", paraStack->data[i]);	
	}
	printf("\r\n");
} 
/*
 * 初始化一个空栈  
 */
CharStackPtr charStackInit(){
	CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(CharStackPtr));
	resultPtr->top = -1;
	
	return resultPtr;  
} 

/*
 * 把一个元素插入栈中  
 * @param paraValue 被插入的元素 
 */
void push(CharStackPtr paraStackPtr, int paraValue){
	// Step 1. 检查空间
	if(paraStackPtr->top >= STACK_MAX_SIZE - 1){
		printf("Cannot push element: stack full.\r\n");
		return;
	}
	
	// Step 2. 更新栈top数据
	paraStackPtr->top++;
	
	// Step 3. 插入元素
	paraStackPtr->data[paraStackPtr->top] = paraValue; 
}

/*
 * 把一个元素从栈中删除  
 * @return 被删除的数据 
 */
char pop(CharStackPtr paraStackPtr){
	// Step 1. 检查空间
	if(paraStackPtr->top < 0){
		printf("Cannot pop element: stack empty.\r\n");
		return '\0';
	}
	
	// Step 2. 更新栈top数据
	paraStackPtr->top--;
	
	// Step 3. 删除元素
	return paraStackPtr->data[paraStackPtr->top+1]; 
} 

/*
 * 功能测试 
 */
void pushPopTest(){
	printf("---- pushPopTest begins. ----\r\n");
	
	// 初始化
	CharStackPtr tempStack = charStackInit();
	printf("After initialization, the stack is: ");
	outputStack(tempStack);
	
	// 栈的插入
	for( char ch = 'a'; ch < 'm'; ch++){
		printf("Pushing %c.\r\n", ch);
		push(tempStack, ch);
		outputStack(tempStack);
	}
			
	// 栈的删除
	for( int i = 0; i < 3; i ++){
		char ch = pop(tempStack);
		printf("Pop %c.\r\n", ch);
		outputStack(tempStack);
	}  
	
	printf("---- pushPopTest ends. ----\r\n");
} 
/*
 * 程序入口 
 */
int main(){
	pushPopTest();
	return 0;
}
#include <stdio.h>
#include <malloc.h>
#define true 1
#define false 0
#define bool _Bool
#define STACK_MAX_SIZE 10

/*
 * 线性整型堆栈。 
 */
typedef struct CharStack{
 	int top;
 	
 	int data[STACK_MAX_SIZE];
 } *CharStackPtr;

/*
 * 输出栈 
 */
void outputStack(CharStackPtr paraStack){
	for(int i = 0; i<= paraStack->top; i++){
 		printf("%c ", paraStack->data[i]);	
	}
	printf("\r\n");
} 
/*
 * 初始化一个空栈  
 */
CharStackPtr charStackInit(){
	CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(struct CharStack));
	resultPtr->top = -1;
	
	return resultPtr;  
} 

/*
 * 把一个元素插入栈中  
 * @param paraValue 被插入的元素 
 */
void push(CharStackPtr paraStackPtr, int paraValue){
	// Step 1. 检查空间
	if(paraStackPtr->top >= STACK_MAX_SIZE - 1){
		printf("Cannot push element: stack full.\r\n");
		return;
	}
	
	// Step 2. 更新栈top数据
	paraStackPtr->top++;
	
	// Step 3. 插入元素
	paraStackPtr->data[paraStackPtr->top] = paraValue; 
}

/*
 * 把一个元素从栈中删除  
 * @return 被删除的数据 
 */
char pop(CharStackPtr paraStackPtr){
	// Step 1. 检查空间
	if(paraStackPtr->top < 0){
		printf("Cannot pop element: stack empty.\r\n");
		return '\0';
	}
	
	// Step 2. 更新栈top数据
	paraStackPtr->top--;
	
	// Step 3. 删除元素
	return paraStackPtr->data[paraStackPtr->top+1]; 
} 

/*
 * 检查括号是否匹配 
 */
bool bracketMatching(char* paraString, int paraLength){
	// Step 1. 初始化栈，将'#'放在栈的底部
	CharStackPtr tempStack = charStackInit();
	push(tempStack, '#');
	char tempChar, tempPopedChar;
	
	// Step 2.  顺序判断
	for(int i = 0;i < paraLength; i++){
		tempChar = paraString[i];
		
		switch(tempChar){
			case'(':
			case'[':
			case'{':
				push(tempStack, tempChar);
				break;
			case')':
				tempPopedChar = pop(tempStack);
				if(tempPopedChar != '('){
					return false;
				}
                break;
			case']':
				tempPopedChar = pop(tempStack);
				if(tempPopedChar != '['){
					return false;
				}
                break;
			case'}':
				tempPopedChar = pop(tempStack);
				if(tempPopedChar != '{'){
					return false;
				}
                break;
			default:
				break;
		}
	} 
    tempPopedChar = pop(tempStack);
	if(tempPopedChar != '#'){
		return false;
	}
	return true;
} 

/*
 * 功能测试
 */
void bracketMatchingTest() {
	char* tempExpression = "[2 + (1 - 3)] * 4";
	bool tempMatch = bracketMatching(tempExpression, 17);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);


	tempExpression = "( )  )";
	tempMatch = bracketMatching(tempExpression, 6);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);

	tempExpression = "()()(())";
	tempMatch = bracketMatching(tempExpression, 8);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);

	tempExpression = "({}[])";
	tempMatch = bracketMatching(tempExpression, 6);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);


	tempExpression = ")(";
	tempMatch = bracketMatching(tempExpression, 2);
	printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);
}

/*
 * 程序入口 
 */
int main(){
	bracketMatchingTest();
	return 0;
}

greatwaves11
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
数据结构之线性表栈队列
kuangfeng的博客
02-20 2118
数据结构之线性表栈队列、实现方式和顺序表示、栈和队列的共同点和不同点
python 栈 数据结构 作业
04-02
python 栈 数据结构 作业
数据结构 作业 --栈和队列
liuxiaocs7的博客
10-06 323
刚开始题目看了半天，没看懂。。。 其实就是将SH混合字符串输出为SSSHHH的形式 思路 遍历遇到H入栈暂存，遇到S直接添加到输出字符串中 //火车入栈问题 //使用顺序栈 char* TrainSeat(char *out, const char *in) { SqStack&amp;lt;char&amp;gt; seatStack; int i = 0; while (*in != '\0') {...
数据结构作业（栈）
Alsp111的博客
05-10 267
栈：栈是限定仅在表尾进行插入或删除的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶，相应地，表头端称为栈底。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的，因此，栈又称为后进先出的线性表。 创建栈： typedef struct CharStack { int top; int data[STACK_MAX_SIZE]; } *CharStackPtr; 栈的初始化： CharStackPtr charStackInit() { CharStackPtr
线性数据结构之栈(Stack)
热门推荐
刘跃辉的博客
09-05 9万+
栈是一种用于存储数据的简单数据结构(与链表类似) , 栈的关键就是入栈的次序 , 比如我们在交作业的时候 , 最先交的永远都在最后面 , 而老师检查的时候是从最上面开始拿 , 所以第一个交的作业老师最后一个看完栈是一个有序的线性表 , 只能在表的一端(称为栈顶 , top)执行插入和删除操作 , 最后插入的元素将被第一个删除 , 所以栈也被称为后进先出(Last In First Out : LIFO)或者是先进后出(First In Last Out : FILO)线性表。
数据结构作业 栈的操作
qiufeng12341的博客
11-19 1137
#include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR -1 #define MAXSIZE 10 typedef int Status; typedef struct Node{ int data; //结点的数据域 struct Node *next;//结点的指针域 int stacksize; }Node,*LinkList; int i=0;//记录栈中...
《大话数据结构》06 栈
阿钊侃技术的博客
04-19 1178
栈是我们在数据结构和任何编程语言中都无法绕开的一个关键节点，这篇文章让你彻底读懂栈
BUAA数据结构第四次作业2023
weixin_50567399的博客
04-21 3562
BUAA数据结构第四次上机作业
[数据结构]绪论作业
Linyeji的博客
11-28 1133
22 . 下面说法错误的是（ ） (1）算法原地工作的含义是指不需要任何额外的辅助空间 （2）在相同的规模n下，复杂度O(n)的算法在时间上总是优于复杂度O(2n)的算法 （3）所谓时间复杂度是指最坏情况下，估算算法执行时间的一个上界 （4）同一个算法，实现语言的级别越高，执行效率就越低。其中 n为正整数，则最后一行的语句频度在最坏情况下是（ ）解析：二元组(D,R)是数据逻辑结构的一种通用描述方法，其中D是数据元素的集合，R是数据元素关系的集合，在D上可以多种关系，每个关系用序偶来表示。
常州工学院数据结构作业-第3章 栈和队列
qq_62011165的博客
10-20 767
3.1 简答题(不用抄题目) 1. 栈的两种存储结构是什么？ 栈的存储结构 和线性表类似，栈也有两种基本的存储结构：顺序存储结构和链式存储结构。 顺序栈： 顺序栈是使用顺序存储结构实现的栈，即利用一组地址连续的存储单元依次存放栈中的数据元素。 由于栈是一种特殊的线性表，因此在线性表的顺序存储结构的基础上，选择线性表的一端作为栈顶即可。 根据数组操作的特性，选择数组下标大的一端，即线性表顺序存储的表尾来作为栈顶，此时入栈、出栈等操作可以在Ο(1)时间完成。
用栈实现计算器（数据结构作业）
水蛙菌
11-16 3万+
用栈实现计算器（数据结构作业） 用栈实现一个计算器，计算器的功能包括： 1.加减乘除四则运算 2.含括号的运算 3.小数乘法和除法运算 以下是我的代码，很难找到比我这个还短的代码了吧～(￣▽￣～) #include<bits/stdc++.h> using namespace std; int cmp(char c) { if(c == '-' || c == '+') return 1; if(c == '*' || c == '/') return 2; return 0; } voi
顺序栈ADT数据结构代码
12-02
顺序栈ADT数据结构代码，注释多，适合初学或者作业学习，用C语言实现，在VisualStudio写的，可以直接将文件添加进工程，在控制台查看效果
c++ QT 数据结构 栈计算器
04-09
数据结构栈作业，基于顺序栈的计算器，使用C++编写逻辑，QT制作ui
数据结构C语言期末实验作业
08-15
适合大一，大二学生，数据结构期末作业带有顺序表+链表+顺序栈+链栈+顺序队列+链队+二叉树(先序遍历+中序遍历+后序遍历)带结构图
大连理工数据结构作业
11-05
大连理工大学数据结构的课后作业，包括线性表，栈，队列，树，图，查找。排序内容。
高级数据结构-树状数组
weixin_72982195的博客
05-29 422
基本知识：1.lowbit运算2.树状数组及其应用a[N]是原始数组；c[N]是树状数组，存放数组a中i号位之前的lowbit(i)个元素之和，c[i]覆盖长度是lowbit(i)特别强调 树状数组的下标必须从1开始！！！（1）.函数getSum(x)，返回前x个数之和a[1]+a[2]+......a[x].（2）.函数update(x,c).实现将第x个数加上一个数v的功能，即a[x] += c；例题1：在完成了分配任务之后，西部 314来到了楼兰古城的西部。
数据结构--链表
pzn2506的博客
05-30 1269
想象⼀下这样的场景，假设每节⻋厢的⻋⻔都是锁上的状 态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从⻋头⾛到⻋尾？链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。链表中每个节点都是独⽴申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个节点的。最简单的做法：每节⻋厢⾥都放⼀把下⼀节⻋厢的钥匙。
数据结构--拓扑排序
最新发布
Zhang_Qin123的博客
05-31 555
对于一个进行拓扑排序，是将G中所有节点排成一个线性序列，该序列满足以下两个条件：① 每个节点有且仅出现一次 ② 若存在一条从节点A到节点B的路径，则在序列中A一定出现在B前面。对于求一个有向无环图的拓扑排序步骤：1.在图中找到一个没有前驱(入度为0)的节点，然后输出2. 从图中删除该节点和所有以它为起点的有向边3.重复操作1和操作2，直到图为空 或 当前图不存在无前驱的顶点为止第一步操作，删除节点 1第二步操作，删除节点 2第三步操作，删除节点4最后拓扑排序依次为 3 5，不再画图讲述。
数据结构之链表（算法之初）
FENGCHEN____的博客
05-27 477
int value;} ListNode;int value;} ListNode;int value;
educoder数据结构栈和队列作业
04-10
educoder是一个在线编程学习平台，提供了丰富的编程题目和学习资源。在educoder上，你可以学习和练习各种编程语言和数据结构算法。 关于数据结构中的栈和队列，它们都是常用的线性数据结构，具有不同的特点和应用场景。 1. 栈（Stack）是一种后进先出（LIFO）的数据结构，类似于现实生活中的一叠盘子。栈的特点是只能在栈顶进行插入和删除操作，即只能在一端进行操作。常见的栈操作包括入栈（push）和出栈（pop）。栈的应用场景包括函数调用、表达式求值、括号匹配等。 2. 队列（Queue）是一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。队列的特点是只能在队尾进行插入操作，在队头进行删除操作。常见的队列操作包括入队（enqueue）和出队（dequeue）。队列的应用场景包括任务调度、消息传递、广度优先搜索等。 在educoder上，你可以通过完成相关的编程题目来学习和巩固栈和队列的使用。这些题目会涉及到栈和队列的基本操作、应用场景以及相关算法的实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值