数据结构与算法5：栈和队列（相关算法：括号匹配问题（有效的括号））

于 2022-12-01 09:43:04 发布
阅读量327 收藏
点赞数
文章标签： 算法 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44902386/article/details/128126036
版权

栈

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。
栈的实现一般可以使用数组和链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较少。

//stack.h  动态为数组分配空间
#pragma once
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

typedef int STDataType;

//#define MAX 10000
//struct Stack {
//	STDataType a[MAX];
//	int top;
//};

typedef struct Stack {
	STDataType* a;
	int capacity;
	int top;
}ST;

void StackInit(ST* ps);
void StackDestory(ST* ps);
//入栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);

STDataType StackTop(ST* ps);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);


//stack.c
#include "stack.h"

void StackInit(ST* ps) {
	assert(ps);
	//如果初始top是0，那么top指向的是栈顶元素的下一个
	//如果初始top是-1，那么top指向的是栈顶元素
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL) {
		printf("realloc fail!");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
}
void StackDestory(ST* ps) {
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
//入栈
void StackPush(ST* ps, STDataType x) {
	assert(ps);
	//满了
	if (ps->top == ps->capacity) {
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (NULL == tmp) {//判断相等还是尽量常量写在左边，这个错误找了半个小时
			printf("realloc fail!");
			exit(-1);
		}
		else {
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//出栈
void StackPop(ST* ps) {
	assert(ps);
	//栈空了，调用pop，报错
	                         assert(ps->top > 0);
	ps->top--;
}

STDataType StackTop(ST* ps) {
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}
int StackSize(ST* ps) {
	assert(ps);
	return ps->top;
}
bool StackEmpty(ST* ps) {
	assert(ps);
	return ps->top == 0;
}

//test.c
#include "stack.h"
int main() {
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	printf("%d ", StackTop(&st));
	StackPop(&st);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPush(&st, 5);
	while (!StackEmpty(&st)) {
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	StackDestory(&st);
	return 0;
}

队列

队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出特点。
入队列：进行插入操作的一端称为队尾。
出队列：进行删除操作的一端称为队头。
队列的实现一般可以使用数组和链表，相对而言链表的结构实现较优，链表可以使用尾插和头删，实现先进先出。

数组:不适合，队头出数据需要挪动数据

单链表：尾插头删效率都很高

//test.c
#include "stack.h"
int main() {
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	while (!QueueEmpty(&q)) {
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	return 0;
}

//Queue.c

#include "stack.h"

void QueueInit(Queue* pq) {
	assert(pq);
	pq->head = pq->tail = NULL;

}void QueueDestory(Queue* pq) {
	assert(pq);
	QNode* cur = pq->head;
	while (cur) {
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x) {
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL) {
		printf("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL) {
		pq->head = pq->tail = newnode;
	}
	else {
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

void QueuePop(Queue* pq) {
	assert(pq);
	assert(pq->head);
	if (pq->head->next == NULL) {
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else {
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

QDataType QueueFront(Queue* pq) {
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}
QDataType QueueBack(Queue* pq) {
	assert(pq);
	assert(pq->head);
	return pq->tail->data;
}

int QueueSize(Queue* pq) {
	assert(pq);
	int size = 0;
	QNode* cur = pq->head;
	while (cur) {
		size++;
		cur = cur->next;
	}
	return size;
}
bool QueueEmpty(Queue* pq) {
	assert(pq);
	return pq->head == NULL;
}

//Queue.h
#pragma once
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

typedef int QDataType;

typedef struct QueueNode {
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue {
	QNode* head;
	QNode* tail;
}Queue;

void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);

void QueuePush(Queue* pq,QDataType x);
void QueuePop(Queue* pq);

QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);

int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);

算法：有效的括号

给定一个只包含’ ( ', ’ ) ', ’ { ', ’ } ', ’ [ ', ’ ] ’ 的字符串s，判断字符串是否有效。

有效字符串满足：

  1. 左括号必须用相同类型的右括号闭合
  2. 左括号必须以正确的顺序闭合
  3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = “()”
输出：true

示例 2：

输入：s = “()[]{}”
输出：true

示例 3：

输入：s = “(]”
输出：false

思路：如果是左括号入栈，要是右括号首先判断栈是否为空，如果为空，返回false，如果不为空，取栈顶的元素，再判断栈顶的元素是否和要入栈的元素匹配。如果匹配就++继续看是否匹配，如果不匹配返回false，比较完后，判断元素时候为空，因为有可能全是左括号入栈，而没有右括号匹配，消除这种错误。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>


typedef char STDataType;
typedef struct Stack {
	STDataType* a;
	int capacity;
	int top;
}ST;

void StackInit(ST* ps);
void StackDestory(ST* ps);
//入栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);

STDataType StackTop(ST* ps);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);


void StackInit(ST* ps) {
	assert(ps);
	//如果初始top是0，那么top指向的是栈顶元素的下一个
	//如果初始top是-1，那么top指向的是栈顶元素
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL) {
		printf("realloc fail!");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
}
void StackDestory(ST* ps) {
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
//入栈
void StackPush(ST* ps, STDataType x) {
	assert(ps);
	//满了
	if (ps->top == ps->capacity) {
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (NULL == tmp) {
			printf("realloc fail!");
			exit(-1);
		}
		else {
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//出栈
void StackPop(ST* ps) {
	assert(ps);

	assert(ps->top > 0);
	ps->top--;
}

STDataType StackTop(ST* ps) {
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}
int StackSize(ST* ps) {
	assert(ps);
	return ps->top;
}
bool StackEmpty(ST* ps) {
	assert(ps);
	return ps->top == 0;
}

bool isValid(char* s) {
	ST st;
	StackInit(&st);
	while (*s != '\0') {
		switch (*s) {
		case '{':
		case '[':
		case '(': {
			StackPush(&st, *s);
			s++;
			break;
		}
		case '}':
		case ']':
		case ')': {
			if (StackEmpty(&st)) {
				StackDestory(&st);
				return false;
			}
			char top = StackTop(&st);
			StackPop(&st);
			//匹配
			if ((*s == '}' && top != '{')
				|| (*s == ']' && top != '[')
				|| (*s == ')' && top != '(')) {
				
				s++;
			}
			//不匹配
			else {
				StackDestory(&st);
				return false;
			}
			break;
		}
		default:
			break;
		}
	}
	bool ret = StackEmpty(&st);
	StackDestory(&st);
	return ret;

}
yiyakaa
关注
栈和队列应用之括号匹配
lhyer的专栏
08-14 2767
一.题目描述 假设一个表达式或一段程序中含有三种括号：圆括号“（”和“）”、方括号“[”和“]”、花括号“{”和“}”。试写一个程序判别给定的表达式或程序中所含括号是否正确配对出现。 输入说明： 多组输入数据，第1行为1个正整数n，表明有n组测试数据；其余n行为n组测试数据，每行为一个含有括号的表达式或一段程序。 输出说明： 对于每一组测试数据，输出一个right或wrong，表明正确
python每日算法 | 数据结构基础：栈与队列以及经典的迷宫问题
REPCHAOCHAO的博客
09-12 1290
python每日算法：数据结构基础知识（一）：栈与队列以及最经典的迷宫问题
数据结构 栈与队列（一） 括号匹配
胡乱写点什么
02-11 1230
数据结构（四） 学习数据结构与算法过程中的心得体会以及知识点的整理，方便我自己查找，也希望可以和大家一起交流。 —— 括号匹配 —— 1.题目描述 Candela是一名漫画家，她有一个奇特的爱好，就是在纸上画括号。这一天，刚刚起床的Candela画了一排括号序列，其中包含小括号()、中括号[]和大括号{}，总长度为N。这排随意绘制的括号序列显得杂乱无章，于是Candela定义了什么样的括号序列是...
栈与队列 括号匹配
qq_32639797的博客
02-24 249
7-3 括号匹配 给定一串字符，不超过100个字符，可能包括括号、数字、字母、标点符号、空格，编程检查这一串字符中的( ) ,[ ],{ }是否匹配。 输入格式: 输入在一行中给出一行字符串，不超过100个字符，可能包括括号、数字、字母、标点符号、空格。 输出格式: 如果括号配对，输出yes，否则输出no。 #include<stack> #include<iostream> using namespace std; int main() { stack<char&
栈和队列 - 用栈实现括号匹配
一杯红酒7的博客
03-24 384
1.题目 LeetCode: 20. 有效的括号 【easy】 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 示例 1： 输入：s = “()” 输出：true 示例 2： 输入：s = “()[]{}” 输出：true 示例 3： 输入：s = “(]” 输出：false 示例 4： 输入：s = “([)]” 输出：false 示例 5： 输入：s = “{[]}
Leecode刷题——栈和队列——括号匹配（栈的应用）
m0_67646485的博客
05-15 384
计算机程序中有非常多的栈的应用，其中最典型的就是括号匹配，以此来更深入的了解一下栈的原理 例题：20.有效的括号 代码： class Solution { public boolean isValid(String s) { Stack<Character> stack = new Stack<>(); char ch; for(int i=0;i<s.length();i++){ ch
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
算法与数据结构：5-栈和队列2.pdf
09-20
最后，文件中提到的第3讲习题1和第3讲习题2，虽然没有给出具体的内容，但可以推断它们是与栈和队列相关联的练习题，可能是基于栈的递归、表达式求值、括号匹配，或者基于队列的广度优先搜索、循环队列的实现等等。...
基于PHP实现栈数据结构和括号匹配算法示例
12-19
- PHP数据结构相关的教程，如《PHP数据结构与算法教程》、《PHP程序设计算法总结》等，可以帮助深入理解数据结构和算法。 - 其他编程语言（如C++、Java）实现括号匹配的实例，提供了不同语言环境下的解决方案。 ...
数据结构与算法-实验3 栈和队列
最新发布
11-19
**栈**是一种后进先出（LIFO, Last In First Out）的数据结构，常被用于表达式求值、括号匹配等问题。实验中提到了顺序栈和链栈的实现： 1. **顺序栈**：使用数组作为底层存储结构，通常通过top指针追踪栈顶元素的...
数据结构实验之栈与队列四：括号匹配
qq_45885219的博客
08-16 597
数据结构实验之栈与队列四：括号匹配 Description 给你一串字符，不超过50个字符，可能包括括号、数字、字母、标点符号、空格，你的任务是检查这一串字符中的( ) ,[ ],{ }是否匹配。 Input 输入数据有多组，处理到文件结束。 Output 如果匹配就输出“yes”，不匹配输出“no” Sample Input sin(20+10) {[}] Output yes no #include <stdio.h> #include <stdlib.h> #include &
数据结构练习题之栈与队列：括号匹配问题（C语言实现）
BaoITcore的博客
11-20 8307
这只是其中一个例题，看完我对这道题的分析之后，关于括号匹配的问题你肯定能够掌握个差不多。转载请注明本文链接！ 目录 一、问题描述 二、问题分析 三、代码实现 （一）、定义结构体 （二）、初始化栈 （三）、进栈函数 （四）、判断栈是否为空 （五）、出栈函数 （六）、获取栈顶元素 （七）、主函数 （八）、运行结果 四、完整代码 一、问题描述 Description 给你一串字符，不超过50个字符，可能包括括号、数字、字母、标点符号、空格，你的...
LeetCode 数据结构与算法之有效的括号
qwer123451234123的博客
04-21 103
题目 有效的括号 给定一个只包括 '('，')'，'{'，'}'，'['，']'的字符串 s ，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 示例 1： 输入：s = "()" 输出：true 复制代码 示例2： 输入：s = "()[]{}" 输出：true 复制代码 示例3： 输入：s = "(]" 输出：false 复制代码 示例4： 输入：s = "([)]" 输出：false 复制代码 示例...
Python实现数据结构与算法——有效的括号
Mantana的博客
03-06 388
题目描述： 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例1： 输入: "()" 输出: true 示例2： 输入: "()[]{}" 输出: true 示例3： 输入: "(]" 输出: false 示例4： 输入:...
数据结构5-栈与队列的应用(括号匹配的问题、表达式求值问题)
渐渐的忘记，赶不上明天（读研ing，2024年毕业）
05-09 787
文章目录1. 栈的应用1.1 括号匹配的问题1.1.1 匹配的过程分析1.1.2 算法的实现1.1.2.1 顺序队列实现1.1.2.2 链式队列实现1.2 表达式求值问题1.2.1 表达式求值问题的分析1.2.1.1 中缀表达式1.2.1.2 后缀表达式(逆波兰表达式)1.2.1.3 前缀表达式(波兰表达式)1.2.1.4 中缀表达式转后缀表达式1.2.1.5 中缀表达式转前缀表达式1.2.1.6...
栈和队列之括号匹配
zzu-hust-madd
10-23 434
括号匹配 算法描述 检验表达式中括号是否合法 代码描述 源代码： #include <stdio.h> #include <malloc.h> #include <stdlib.h> //定义一个栈 typedef struct Stack{ char *top; char *bottom; int size; }Stack,*PSta...
[栈和队列]括号匹配
大道至简 悟在天成
05-01 528
#include #include #include #define INIT_STACK_SIZE 100 typedef struct { char * chOperator; int dwtop; }OPND; void InitStack(OPND *); char Pop(OPND *); void Push(OPND *,char ); char GetTop(
数据与结构总结篇--栈与队列之括号匹配
梦灵-影的博客
09-05 126
#include<iostream> #include<stdlib.h> using namespace std; #define MaxSize 6 typedef struct { char data[MaxSize]; int top; }SqStack; void InitStack(SqStack& S) { S.top = -1; } int StackEmpty(SqStack S) { if (S.top == -1) return 1; el.
括号匹配(栈和队列)
weixin_30825199的博客
03-28 407
Description假设一个算术表达式中可以包含三种括号：圆括号“(”和“)”，方括号“[”和“]”和花括号“{”和“ ”，且这三种括号可按任意的次序嵌套使用（如：…[…{… …[…]…]…[…]…(…)…)。编写判别给定表达式中所含括号是否正确配对出现的算法。输出结果YES 或者 NO。 Input5+{[2X5]+2} OutputYES Sample Input8-[{2+...
数据结构与算法解析：栈&队列深度解析
"数据结构与算法--栈&队列 很好的哦 欢迎下载" 在计算机科学中，数据结构和算法是编程的基础，而栈和队列是两种最基本且重要的数据结构。本资料深入讲解了这两者的核心概念及其应用。 栈（Stack）是一种特殊类型的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值