【数据结构】栈及栈的应用

最新推荐文章于 2024-07-06 22:16:55 发布
最新推荐文章于 2024-07-06 22:16:55 发布
阅读量943 收藏 8
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OddSmurfs/article/details/82847886
版权

栈

栈是一种先进后出的的特殊线性表，只允许在固定的一端进行插入和删除元素操作，进行输入插入和删除操作的一端称为栈顶，另一端称为栈底

下面采用静态顺序表实现的方式简单封装一个栈

存储方式

#define MAX_SIZE 100
typedef int DataType;

typedef struct
{
	DataType arr[MAX_SIZE];
	int top;
}Stack;

相应操作

void StackInit(Stack *ps)
{
	ps->top = 0;
}
void StackDestroy(Stack *ps)
{
	ps->top = 0;
}
void StackPush(Stack *ps, DataType data)
{
	assert(ps->top < MAX_SIZE);
	ps->arr[ps->top++] = data;
}
void StackPop(Stack *ps)
{
	assert(ps->top > 0);
	ps->top--;
}
DataType StackTop(Stack *ps)
{
	return ps->arr[ps->top - 1];
}
int StackSize(Stack *ps)
{
	return ps->top;
}
int StackEmpty(Stack *ps)
{
	return ps->top == 0 ? 1 : 0;
}

栈的应用

括号匹配问题

将需要检验的文档以字符串的方式表示，遍历整个字符串，遍历的过程中会出现三种情况
（1）左括号：遇到左括号进行入栈操作
（2）右括号：遇到右括号需要判断栈当前的状态。如果栈为空，则直接可以断定右括号多（在遍历的过程中只有左括号入栈）；如果栈不为空，则判断栈顶元素和当前遍历到的括号是否匹配，如果匹配则出栈，不匹配表明不匹配
（3）其他字符：不做处理，继续向后遍历
遍历完整个字符串的时候判断最后栈是否为空，为空则表示括号匹配，如果不为空，则表示左括号多

void MatchBrackets(char *str)
{
	Stack stack;
	StackInit(&stack);
	while (*str != '\0')
	{
		if (*str == '(' || *str == '[' || *str == '{')
		{
			StackPush(&stack, *str);
		}
		else if (*str == ')' || *str == ']' || *str == '}')
		{
			if (StackEmpty(&stack))
			{
				printf("右括号多\n");
				return;
			}
			else
			{
				if ((StackTop(&stack) == '(' && *str == ')')
					|| (StackTop(&stack) == '[' && *str == ']')
					|| (StackTop(&stack) == '{' && *str == '}'))
				{
					StackPop(&stack);
				}
				else
				{
					printf("括号不匹配\n");
					return;
				}
			}
		}
		str++;
	}
	if (StackEmpty(&stack))
	{
		printf("匹配成功\n");
	}
	else
	{
		printf("左括号多\n");
	}
}

在这里插入图片描述

RPN求值

为了方便用C语言对后缀表达式进行标识，用结构体和枚举进行封装，用Item类型的数组来存放整个后缀表达式

typedef enum 
{
    NUMBER,
    OPRETOR
}Type;

typedef enum
{
    ADD,
    SUB,
    MUL,
    DIV
}OP;

typedef struct
{
    Type type;
    int number;
    OP opreator;
}Item;

遍历整个数组，遇到操作数压栈

遇到操作符连续出栈两次，根据此操作数对出栈的两个操作数做相应处理，然后将结果压入栈中（要注意DIV 和 SUB操作时，左右两个操作数的顺序）

遍历完整个数组，栈中只剩下的最后一个元素，则是整个表达式的结果

int RPN(Item *arr, int sz)
{
	Stack stack;
	int operand1 = 0;
	int operand2 = 0;
	OP tmp;
	StackInit(&stack);
	while (sz--)
	{
		if (arr->type == NUMBER)
		{
			StackPush(&stack, arr->number);
		}
		else
		{
			tmp = arr->opreator;
			operand1 = StackTop(&stack);
			StackPop(&stack);
			operand2 = StackTop(&stack);
			StackPop(&stack);

			switch(tmp)
			{
			case ADD:
				{
					StackPush(&stack, operand1+operand2);
				}
				break;
			case SUB:
				{
					StackPush(&stack, operand2-operand1);
				}
				break;
			case MUL:
				{
					StackPush(&stack, operand2*operand1);
				}
				break;
			case DIV:
				{
					StackPush(&stack, operand2/operand1);
				}
				break;
			default:
				break;
			}
		}
		arr++;
	}
	return StackTop(&stack);
}

int main()
{
	int result = 0;
	Item arr[] = {
		{NUMBER, 12, DEFAULT},
		{NUMBER, 3, DEFAULT},
		{NUMBER, 4, DEFAULT},
		{OPRETOR, -1, ADD},
		{OPRETOR, -1, MUL},
		{NUMBER, 6, DEFAULT},
		{OPRETOR, -1, SUB},
		{NUMBER, 8, DEFAULT},
		{NUMBER, 2, DEFAULT},
		{OPRETOR, -1, DIV},
		{OPRETOR, -1, ADD},
	};
	int size = sizeof(arr)/sizeof(arr[0]);
	result = RPN(arr, size);
	printf("%d\n", result);


	return 0;
}

在这里插入图片描述

迷宫

采用回溯法来找迷宫出口

回溯法：对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为若干个子问题求解的算法。当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯到该结点的前一个结点，继续搜索该结点外的其他尚未搜索的分支；如果发现该结点无法再继续搜索下去，就让搜索过程回溯到这个结点的前一个结点继续这样的搜索过程；一直进行下去，直到搜索到问题的解或者搜索完了全部可搜索的分支没有解存在为止

借助栈来完成回溯，用一个二维数组来构造迷宫，可走路线标记为1，墙标记为0，用一个结构体封装二维数组元素的坐标，所以与普通栈有差异的是用于存放迷宫位置的数据类型也是一个结构体，封装了这个二维数组的横纵坐标

typedef struct Coordinates
{
	int x;
	int y;
}Coordinates;

typedef Coordinates DataType;

typedef struct
{
	DataType arr[MAX_SIZE];
	int top;
}Stack;
简单迷宫

二维数组构造简单迷宫：

	int Maze[6][6] = {
		{0,0,0,0,0,0},
		{0,0,1,0,0,0},
		{0,0,1,0,0,0},
		{0,0,1,1,1,0},
		{0,0,1,0,1,1},
		{0,0,1,0,0,0}
	};

按左、上、右、下的顺序进行尝试，将走过的位置压入栈中，每走一步都对走过的位置进行标记，防止重复循环，无路可走时进行回溯，回溯的时候记得出栈，走过的路通过再次标记的方式避免重复走，所以如果能走，则选择的是与前面不同的路线，在走的过程中判断当前位置是否为出口，如果是出口函数renturn即可

用栈实现回溯时无法判断回溯后的位置已尝试的方向，所以必须要对走之后和回溯过的位置进行标记

void PrintMaze(int Maze[][6])
{
	int i = 0;
	int j = 0;
	for (; i < 6; i++)
	{
		for (j = 0; j < 6; j++)
		{
			if (Maze[i][j] == 0)
			{
				printf("█");
			}
			else if (Maze[i][j] == 1)
			{
				printf("  ");
			}
			else if (Maze[i][j] == 3)
			{
				printf("  ");
			}
			else
			{
				printf("★");
			}
		}
		printf("\n");
	}
}
void FindExport(int Maze[][6], Coordinates* p)
{
	Stack stack;
	Coordinates pos;
	StackInit(&stack);

	pos.x = p->x;
	pos.y = p->y;

	StackPush(&stack, pos);//先把入口压入栈中
	while (1)
	{


		Maze[pos.x][pos.y] = 2;
		//左
		if (Maze[pos.x][pos.y - 1] == 1)
		{
			pos.y -= 1;
			StackPush(&stack, pos);
			Maze[pos.x][pos.y] = 2;
			if ((pos.x == 0 || pos.x == 5) || (pos.y == 0 || pos.y == 5))
			{
				printf("找到出口\n");
				PrintMaze(Maze);
				return;
			}
		}
		//上
		else if (Maze[pos.x - 1][pos.y] == 1)
		{
			pos.x -= 1;
			StackPush(&stack, pos);
			Maze[pos.x][pos.y] = 2;

			if ((pos.x == 0 || pos.x == 5) || (pos.y == 0 || pos.y == 5))
			{
				printf("找到出口\n");
				PrintMaze(Maze);
				
				return;
			}
		}

		//右
		else if (Maze[pos.x][pos.y + 1] == 1)
		{
			pos.y += 1;
			StackPush(&stack, pos);
			Maze[pos.x][pos.y] = 2;

			if ((pos.x == 0 || pos.x == 5) || (pos.y == 0 || pos.y == 5))
			{
				printf("找到出口\n");
				PrintMaze(Maze);
				
				return;
			}
		}

		//下
		else if (Maze[pos.x + 1][pos.y] == 1)
		{
			pos.x += 1;
			StackPush(&stack, pos);
			Maze[pos.x][pos.y] = 2;

			if ((pos.x == 0 || pos.x == 5) || (pos.y == 0 || pos.y == 5))
			{
				printf("找到出口\n");
				PrintMaze(Maze);
				
				return;
			}
		}
		else
		{
			Maze[StackTop(&stack).x][StackTop(&stack).y] = 3;
			StackPop(&stack);
			pos = StackTop(&stack);
		}

		system("cls");
		PrintMaze(Maze);
		Sleep(300);
	}
}

在这里插入图片描述

通路间不带环

二维数组构造 通路间不带环迷宫：

	int Maze[7][6] = {
		{0,0,0,0,0,0},
		{0,1,1,1,1,1},
		{0,1,0,0,0,0},
		{0,1,0,1,1,1},
		{0,1,0,1,0,0},
		{0,1,1,1,1,1},
		{0,1,0,0,0,0},
	};

找到出口将出口堵住，让其进行回溯再找下一条出口，直到回溯到入口即栈为空时表示找完了所有出口路线

void PrintMaze(int Maze[][6])
{
	int i = 0;
	int j = 0;
	for (; i < 7; i++)
	{
		for (j = 0; j < 6; j++)
		{
			if (Maze[i][j] == 0)
			{
				printf("█");
			}
			else if (Maze[i][j] == 1)
			{
				printf("  ");
			}
			else if (Maze[i][j] == 3)
			{
				printf("  ");
			}
			else
			{
				printf("★");
			}
		}
		printf("\n");
	}
}
void FindExport(int Maze[][6], Coordinates* p)
{
	Stack stack;
	Coordinates pos;
	StackInit(&stack);

	pos.x = p->x;
	pos.y = p->y;

	StackPush(&stack, pos);//先把入口压入栈中
	while (1)
	{


		Maze[pos.x][pos.y] = 2;
		//左
		if (Maze[pos.x][pos.y - 1] == 1)
		{
			pos.y -= 1;
			StackPush(&stack, pos);
			Maze[pos.x][pos.y] = 2;
			if ((pos.x == 0 || pos.x == 6) || (pos.y == 0 || pos.y == 5))
			{
				printf("找到出口\n");
				PrintMaze(Maze);
				system("pause");
				continue;
			}
		}
		//上
		else if (Maze[pos.x - 1][pos.y] == 1)
		{
			pos.x -= 1;
			StackPush(&stack, pos);
			Maze[pos.x][pos.y] = 2;

			if ((pos.x == 0 || pos.x == 6) || (pos.y == 0 || pos.y == 5))
			{
				printf("找到出口\n");
				PrintMaze(Maze);
				system("pause");
				continue;
			}
		}

		//右
		else if (Maze[pos.x][pos.y + 1] == 1)
		{
			pos.y += 1;
			StackPush(&stack, pos);
			Maze[pos.x][pos.y] = 2;

			if ((pos.x == 0 || pos.x == 6) || (pos.y == 0 || pos.y == 5))
			{
				printf("找到出口\n");
				PrintMaze(Maze);
				system("pause");
				continue;
			}
		}

		//下
		else if (Maze[pos.x + 1][pos.y] == 1)
		{
			pos.x += 1;
			StackPush(&stack, pos);
			Maze[pos.x][pos.y] = 2;

			if ((pos.x == 0 || pos.x == 6) || (pos.y == 0 || pos.y == 5))
			{
				printf("找到出口\n");
				PrintMaze(Maze);
				system("pause");
				continue;
			}
		}
		else
		{
			if (!StackEmpty(&stack))
			{
				Maze[StackTop(&stack).x][StackTop(&stack).y] = 3;
				StackPop(&stack);
			}
			pos = StackTop(&stack);
		}

		if (StackEmpty(&stack))
		{
			printf("再无出口\n");
			return;
		}

		system("cls");
		PrintMaze(Maze);
		Sleep(100);
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

通路间带环

二维数组构造 通路间带环迷宫：

	int Maze[6][6] = {
		{0,0,0,0,0,0},
		{0,1,1,1,0,0},
		{0,1,0,1,0,0},
		{0,1,0,1,0,0},
		{0,1,1,1,1,1},
		{0,1,0,0,0,0},
	};

只有一个出口，不能对出口再进行封堵，采用递归的方式实现，在回溯前将不可再走的位置置为通路

void PrintMaze(int Maze[][6])
{
	int i = 0;
	int j = 0;
	for (; i < 6; i++)
	{
		for (j = 0; j < 6; j++)
		{
			if (Maze[i][j] == 0)
			{
				printf("█");
			}
			else if (Maze[i][j] == 1)
			{
				printf("  ");
			}
			else
			{
				printf("★");
			}
		}
		printf("\n");
	}
}
void FindExport(int Maze[][6], Coordinates* p)
{

	Coordinates nextPos;

	Maze[(*p).x][(*p).y] = 2;
	system("cls");
	PrintMaze(Maze);
	Sleep(100);

	if ((*p).y == 5)
	{
		system("cls");
		printf("找到出口\n");
		PrintMaze(Maze);
		Maze[(*p).x][(*p).y] = 1;
		system("pause");
		return;
	}

	//左
	if (Maze[(*p).x][(*p).y - 1] == 1)
	{
		nextPos = *p;
		nextPos.y -= 1;
		FindExport(Maze, &nextPos);
	}
	//上
	if (Maze[(*p).x - 1][(*p).y] == 1)
	{
		nextPos = *p;
		nextPos.x -= 1;
		FindExport(Maze, &nextPos);
	}

	//右
	if (Maze[(*p).x][(*p).y + 1] == 1)
	{
		nextPos = *p;
		nextPos.y += 1;
		FindExport(Maze, &nextPos);
	}

	//下
	if (Maze[(*p).x + 1][(*p).y] == 1)
	{
		nextPos = *p;
		nextPos.x += 1;
		FindExport(Maze, &nextPos);
	}
	Maze[(*p).x][(*p).y] = 1;//回溯前将不可再走的位置置为通路
}

在这里插入图片描述
在这里插入图片描述

OddSmurfs
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构之栈的实际应用
红莲灭的博客
08-28 337
文章目录栈的实际应用问题描述解题思路代码实现逆波兰表达式求值问题逆波兰表达式问题描述思路分析代码实现 栈的实际应用 ##括号匹配问题 问题描述 给定一个字符串，里面可能包含“（）”小括号和其他字符，编写程序检查该字符串是否成对出现 即有一个（,则有一个）进行匹配，每一个左括号都有一个右括号匹配，且不能有单独的括号出现。 解题思路 1.创建一个栈来存储左括号 2.从左到右遍历字符串，拿到每一个字符 3.判断该字符是不是左括号。如果是放入栈中存储 4.判断该字符是不是右括号，如果不是继续下一次循环遍历 5.如
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
栈及其应用
m0_60128287的博客
05-10 124
1.栈 1.1老师的代码 1.1.1结构体 typedef struct CharStack { int top; int data[STACK_MAX_SIZE]; } *CharStackPtr; 1.1.2初始化 CharStackPtr charStackInit(){ CharStackPtr resultPtr=(CharStackPtr)malloc(sizeof(struct CharStack)); r...
数据结构之“栈”（全方位认识）
最新发布
2302_80867815的博客
07-06 1229
栈是一种数据结构，具有" 后进先出 "的特点 或者也可见说是 ” 先进后出 “。大家一起加油吧冲冲冲！！因为我们这次实现的栈是基于数组实现的，我们就可以参考顺序表的结构体定义来改进。我们了解的栈的定义发现，栈顶元素一直有被提及。我们要定义栈顶，其次我们定义数组，但是为什么我们这边是用指针呢？其实这里数组等价于指针的，在学习指针的时候我们学习过所以我们就像理解指针那一样的思路就可以了。还有就是结构体里面定义指针动态内存管理、高效的内存管理、还方便栈的各种操作。这边提到了内存，也要定义一个数来计算是否满了。
栈的应用
weixin_34397291的博客
08-13 176
由于最近有点忙，本打算写些关于栈的特性和实际应用。一直拖到现在才简单的写写。 关于栈的实现见javascript 栈 stack   一、数字进制之间的转换，可以栈实现。如将十进制转换为八进制 var s = new Stack(); s.Init(); function convert(num){ ...
数据结构-栈及栈的应用
初始化的博客
07-19 4686
栈的概述 栈式一种重要的线性结构，属于一种操作受限的线性表 栈(stack) 是限定尽在表尾进行插入或删除操作的线性表 表尾端称为栈顶(top)，表头端称为栈底(bottom) 栈的元素先进后出(后进先出)，即最先进入栈的元素最后出栈 ...
数据结构实验代码（C++）栈的应用
05-10
在IT领域，数据结构是计算机科学的基础，而栈是一种常用的数据结构，它的操作特性遵循“后进先出”（LIFO）原则。本实验聚焦于栈在处理逆波兰表达式中的应用，这是一种非常实用的计算方法，尤其在编译原理和算法设计...
数据结构栈的实验报告.doc
07-11
综上所述，这个实验主要涵盖了数据结构中顺序栈的基本操作，包括栈的定义、初始化、进栈、出栈的实现，以及如何在实际编程中应用这些操作。通过对这些基本操作的理解和实践，学生能够更好地掌握栈这一重要数据结构的...
【数据结构实验】栈的应用
06-15
实验三 栈的应用 1.实验目的： 熟悉栈的定义，栈的特点以及栈的基本操作。能够根据实际情况选择合适的存储结构，解决实际问题。 2.实验内容： 对任意给定的一个中缀算术表达式,输出等价的后缀形式。
ccc.rar_数据结构 栈的应用
09-21
在这个"ccc.rar_数据结构 栈的应用"压缩包中，我们重点关注的是栈这一特定的数据结构及其在实际问题中的应用。栈是一种线性数据结构，遵循“后进先出”（LIFO）的原则，形象地说，就像是一个堆叠的盘子，最后放上去...
数据结构之栈的应用
Arvin_success的博客
09-09 712
4、栈的应用 栈在计算机科学领域具有广泛地应用。如，在编译和运行计算机语言程序的过程中，就需要利用栈进行语法检查（如｛和｝是否配对）、计算表达式的值、实现递归过程和函数的都要用等。 4.1、将一个十进制数转换为二进制 注：以下程序在VC6.0+WIN98下测试通过 把十进制正整数转换为对应的二进制整数采用逐次除以2取余法，即用基数2不断的去除被转换的正整数，直到商为0。则第一次相除所得余数
栈的表示与实现及栈的应用
yzkzoo
09-21 555
实现栈的顺序存储。栈实现示例#include#include#include#define ERROR 0#define TRUE 1#define FALSE 0#define OK 1#define EQUAL 1#define OVERFLOW -1#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typede
栈的顺序表示及应用
wxdn_xm的博客
09-15 133
#include<iostream> using namespace std; #define STACK_INIT_SIZE 100 #define STACKINCREASE 10 typedef struct { int *base; int *top; int stacksize;//当前已分配存储空间 }SqStack; bool InitStack(SqStack ...
数据结构中的栈
flf1234567898的博客
11-17 252
在刚学习完C语言后，我设计了个程序实现10进制向n进制转换，我发现只能将其最终结果逆序输出。想正序输出一直没有实现。但是当我了解到了栈结构的时候豁然开朗。什么是栈结构？我的理解就是它就像是一个没盖子的瓶子，只能从一端进出。所以就有了先进去的后出来，后进去的先出来的说法。 栈 分为 顺序栈 和 链栈: 1. 顺序栈 和顺序表一样，这个线性结构实质上就是一段线型空间。只不过对这段线性空间进行了限制，而...
栈(简单介绍及其应用)
srg2000的博客
10-28 801
栈的定义 栈是一种只能在一端进行插入或者删除操作的线性表。表中允许插入，删除操作的一端叫做栈顶，另一端叫栈底。 但栈没有数据元素时称为空栈，插入数据操作为进栈或入栈，删除数据操作为出栈或退栈。 栈的特点为后进先出，栈也成为后进先出表。如存入一组数据，顺序为1， 2， 3， 4，则出栈时顺序为4， 3， 2， 1 。 顺序栈 顺序栈采用顺序存储结构进行存储，分配一块连续的存储空间来存放栈中元素，并用一个变量(如int类型的top)指向当前的栈顶元素。 代码实现： 声明顺序栈的类型SqStack(最大个数不超
数据结构栈详解：栈的定义、操作及应用
"特殊线性表——栈-数据结构栈，课件" 栈是一种特殊的数据结构，它具有“后进先出”（Last In First Out，简称LIFO）的特点。在这个课件中，主要讨论了栈的基本概念、存储结构以及一些实际应用。 1. 栈的定义 栈是...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值