数据结构练习题：有效的括号

最新推荐文章于 2024-05-16 21:41:35 发布

囚徒玩电脑

最新推荐文章于 2024-05-16 21:41:35 发布

阅读量41

点赞数 2

分类专栏：数据结构练习题文章标签：数据结构

本文链接：https://blog.csdn.net/m0_74698759/article/details/134132017

版权

数据结构练习题专栏收录该内容

3 篇文章 1 订阅

订阅专栏

题目链接：20. 有效的括号 - 力扣（LeetCode）

题目：给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

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

先来简单理解一下题目，（）、[ ]、{ }必须是这种成双成对的，{（）}这种也属于符合要求。这时候大家可能比较苦恼了，那要怎么弄才行呢？这时候，大家可以想到栈。栈是只能从栈顶出的，那么我们可以假设，左括号入栈；右括号，出栈顶括号，进行匹配。

举个例子，大家来自己的了解一下：

{ { { [ ( ) ] } } }

假设栈顶在右边，第一个是 { ，然后入栈

下一个是 { ，然后入栈

下一个是 { ，然后入栈

下一个是 { ，然后入栈

下一个是 [ ，然后入栈

下一个是 ( ，然后入栈

下一个是 ) ,使用一个变量来储存），然后匹配是否有）；发现有，那就循环继续，如果没有，return false

以此类推，最后发现这个是符合要求的，最后输出true

由于我刚进行了栈的学习，对于OJ题，我准备先复制粘贴我写的栈的相关程序，来完成这道题目。但是也不要害怕，后面学习C++，是不需要这些的。现在只是为了更好地理解栈的概念。

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

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

void STInit(ST* ps);
void STDestroy(ST* ps);
//没有pushback、popback、insert、inerase，是在栈顶入
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
STDataType STTop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);

void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
	assert(ps);

	//假如容量不够，扩容
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void STPop(ST* ps)
{
	assert(ps);

	//空
	assert(ps->top > 0);
	--ps->top;
}
STDataType STTop(ST* ps)
{
	assert(ps);

	//空
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}
bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

但是有一个问题就是，咱们最初学习的栈的STDataType是int类型，现在我们要把int改为char

typedef char STDataType;

改完这个问题之后，我们就可以进行我们OJ题目的完成啦！首先我们来定义一个结构体变量，并且使用我之前写过的栈的初始化函数来进行一个初始化。

	ST st;
	STInit(&st);

接下来我们使用while循环来实现

while(*s)
{
   
   ++s;
}

接下来就是实行判断了，用switch-case语句或者if-else语句均可以，我们先来使用switch-case语句：

先来实行一个大概的框架：

		switch (*s)
		{
		case'[':
		case'(':
		case'{':
		case']':
		case')':
		case'}':
		}

我们前面提到，左括号入栈；右括号，出栈顶括号，进行匹配。

我们先来实现左括号入栈，使用STPush(&st,*s)来实现左括号入栈，即

switch (*s)
		{
		case'[':
		case'(':
		case'{':
			STPush(&st, *s);
			break;

接下来我们来实现右括号，出栈顶括号，进行匹配

1.定义一个变量来将栈顶元素保存

  char top = 0;


		case']':
			//取栈顶元素，将其拷贝在top中
			top = STTop(&st);

2.使用STTop函数来出栈

			//pop掉，即取出栈顶元素
			STPop(&st);

3.判断是否为同类型的左括号；但是如果使用 ==，即使正确，但是有其他的括号需要判断，所以我们改为用 != 来判断是否为同类型，如果不是，直接return false；如果是，那程序继续往下走

			//关注顺序不匹配，匹配继续往后走
			if (top != '[')
				return false;
			break;

判断一个括号的程序汇总如下：


		case']':
			//取栈顶元素，将其拷贝在top中
			top = STTop(&st);
			//pop掉，即取出栈顶元素
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '[')
				return false;
			break;

while总的循环如下：

while (*s)
	{
		switch (*s)
		{
		case'[':
		case'(':
		case'{':
			STPush(&st, *s);
			break;
		case']':
			//取栈顶元素，将其拷贝在top中
			top = STTop(&st);
			//pop掉，即取出栈顶元素
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '[')
				return false;
			break;
		case')':
			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '(')
				return false;
			break;
		case'}':
			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '{')
				return false;
			break;
		}

		++s;
	}

我们继续往下写，使用STDestroy函数来实现，最后return true

总程序如下：

bool isValid(char* s) {
	ST st;
	STInit(&st);
	char top;

	while (*s)
	{
		switch (*s)
		{
		case'[':
		case'(':
		case'{':
			STPush(&st, *s);
			break;
		case']':
			//取栈顶元素，将其拷贝在top中
			top = STTop(&st);
			//pop掉，即取出栈顶元素
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '[')
				return false;
			break;
		case')':
			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '(')
				return false;
			break;
		case'}':
			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '{')
				return false;
			break;
		}

		++s;
	}

	STDestroy(&st);
	return true;
}

这是我们提交测试，发现会出现这样的页面：

我们从这个图里面可以看出，当只有左括号时，顺着循环走，就会来到最后一句return true;

但其实还是存在问题的，这是属于数量的问题，我们可以想到使用STEmpty函数来判断数量是否匹配，即

    //如果栈不为空，false，说明数量不匹配
	bool ret = STEmpty(&st);
	STDestroy(&st);
	return ret;

再次汇总提交代码：

bool isValid(char* s) {
	ST st;
	STInit(&st);
	char top;

	while (*s)
	{
		switch (*s)
		{
		case'[':
		case'(':
		case'{':
			STPush(&st, *s);
			break;
		case']':
			//取栈顶元素，将其拷贝在top中
			top = STTop(&st);
			//pop掉，即取出栈顶元素
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '[')
				return false;
			break;
		case')':
			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '(')
				return false;
			break;
		case'}':
			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '{')
				return false;
			break;
		}

		++s;
	}

	//如果栈不为空，false，说明数量不匹配
	bool ret = STEmpty(&st);
	STDestroy(&st);
	return ret;
}

问题结果如下：

我们可以看出测试案例只给了右括号，是没办法从栈里取出元素的，因此报错了。所有次我得出，我们应该在栈里取元素之前判断栈是否为空，即

         if (STEmpty(&st))
				return false;

整的一个case语句如下：

		    case']':
			//判断栈是否为空，若为空，直接返回false
			if (STEmpty(&st))
				return false;

			//取栈顶元素，将其拷贝在top中
			top = STTop(&st);
			//pop掉，即取出栈顶元素
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '[')
				return false;
			break;

汇总程序如下：

bool isValid(char* s) {
	ST st;
	STInit(&st);
	char top;

	while (*s)
	{
		switch (*s)
		{
		case'[':
		case'(':
		case'{':
			STPush(&st, *s);
			break;
		case']':
			//判断栈是否为空，若为空，直接返回false
			if (STEmpty(&st))
				return false;

			//取栈顶元素，将其拷贝在top中
			top = STTop(&st);
			//pop掉，即取出栈顶元素
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '[')
				return false;
			break;
		case')':
			//判断栈是否为空，若为空，直接返回false
			if (STEmpty(&st))
				return false;

			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '(')
				return false;
			break;
		case'}':
			//判断栈是否为空，若为空，直接返回false
			if (STEmpty(&st))
				return false;

			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '{')
				return false;
			break;
		}

		++s;
	}

	//如果栈不为空，false，说明数量不匹配
	bool ret = STEmpty(&st);
	STDestroy(&st);
	return ret;
}

运行通过啦

但是，我们的右括号部分写的十分冗杂，我们来简化switch-case语句：

先来把这三个右括号单独拿出来看：

        case']':
			//判断栈是否为空，若为空，直接返回false
			if (STEmpty(&st))
				return false;

			//取栈顶元素，将其拷贝在top中
			top = STTop(&st);
			//pop掉，即取出栈顶元素
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '[')
				return false;
			break;
		case')':
			//判断栈是否为空，若为空，直接返回false
			if (STEmpty(&st))
				return false;

			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '(')
				return false;
			break;
		case'}':
			//判断栈是否为空，若为空，直接返回false
			if (STEmpty(&st))
				return false;

			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (top != '{')
				return false;
			break;

我们会发现判断栈是否为空，以及定义变量来存储右括号等都使用了多次。因此，我们来进行简化：

		case']':
		case')':
		case'}':
			//判断栈是否为空，若为空，直接返回false
			if (STEmpty(&st))
				return false;

			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);

加下来就是我们的判断部分了，判断是否相等。但由于十三种类型的括号在一起，所以就用到了我们的

&& 逻辑与（并且）

|| 逻辑或（或者）

具体这两个的操作符可以看C语言初阶之操作符详解-CSDN博客

		case']':
		case')':
		case'}':
			//判断栈是否为空，若为空，直接返回false
			if (STEmpty(&st))
				return false;

			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if (   (*s == ')' && top != '(')
				|| (*s == ']' && top != '[')
				|| (*s == '}' && top != '{'))
			{
				return false;
			}
			break;
		}

化简成功：

用if-else语句

        if(*s == '(' || *s == '[' || *s == '{')
		{
			STPush(&st, *s);
		}
		else
		{
			//数量不匹配
			if (STEmpty(&st))
			{
				STDestroy(&st);
				return false;
			}

			//取栈顶元素
			top = STTop(&st);
			//pop掉
			STPop(&st);
			//关注顺序不匹配，匹配继续往后走
			if ((*s == ')' && top != '(')
				|| (*s == ']' && top != '[')
				|| (*s == '}' && top != '{'))
			{
				STDestroy(&st);
				return false;
			}
        }

只要将 switch-case 语句的部分化成 if-else 语句，该程序就完成啦

这道题的讲解就到此结束啦，但是这道题还有一个隐藏问题，不知道大家发现了没有？就是内存泄露的问题，在每次直接return false的时候，都有可能导致内存泄漏，所以需要使用STDestroy(&st)。本期数据结构题目就讲解到这里啦，我们下期再见！

囚徒玩电脑

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
数据结构练习题：有效的括号

就是内存泄露的问题，在每次直接return false的时候，都有可能导致内存泄漏，所以需要使用STDestroy(&st)。但是如果使用 ==，即使正确，但是有其他的括号需要判断，所以我们改为用!由于我刚进行了栈的学习，对于OJ题，我准备先复制粘贴我写的栈的相关程序，来完成这道题目。但是有一个问题就是，咱们最初学习的栈的STDataType是int类型，现在我们要把int改为char。但其实还是存在问题的，这是属于数量的问题，我们可以想到使用STEmpty函数来判断数量是否匹配，即。
复制链接

扫一扫