栈和队列OJ题

已于 2023-08-25 10:36:22 修改
阅读量183 收藏 25
点赞数 30
文章标签： 数据结构 c语言
于 2023-08-25 10:05:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74190188/article/details/132427470
版权

有效括号问题：

题目描述：

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

有效字符串需满足：

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

思路：

解决此类问题，传统的暴力遍历法已经不再适用了，暴力遍历无法保证括号的匹配顺序，仅能通过统计左右括号的数量进行比较判断，但即使是左右括号数量相等，也不一定是有效的，如：“( [ { ] ) }”，虽然左右括号数量相同，但是它们的顺序不对，不能相互匹配，所以也是无效的，因此，暴力遍历的方法是不行的。

此时我们应该从问题本身出发，思考一下括号匹配的本质是什么？

我们知道一个合法的括号包括两部分：左括号和右括号，括号匹配就是匹配左右括号，并且每次匹配时都是相邻最近的两个左右括号进行匹配。因此，我们可以创建一个数组用来储存左括号，依次遍历，每出现一次左括号就存进这个数组中，每次出现右括号时，将它与数组中最后一个左括号进行匹配，若匹配成功，则删除数组最后一个左括号，再从下一个开始遍历；若匹配不成功，则说明是非法括号字符串，直接退出程序……直至遍历完括号字符串或者中间出现不匹配的情况直接退出。若正常遍历完括号字符串，再看数组中是否为空，若为空，说明该括号字符串中所有左右括号都匹配成功，即该括号字符串合法，反之则是非法的。观察这个匹配规律，不难发现与栈“先入后出”的特点相符合，因此我们可以直接创建一个栈进行实现。

具体代码如下：

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

//判空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
//初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
//销毁
void STDestroy(ST* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
//入栈
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* p = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
		ps->a = p;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->a);
	assert(!STEmpty(ps));
	ps->top--;
}
//取栈顶元素
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(ps->a);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}

bool isValid(char * s)
{
    ST ps;
    STInit(&ps);
    int i=0;
    for(i=0;i<strlen(s);i++)
    {
        if(s[i]=='('||s[i]=='{'||s[i]=='[')//左括号入栈
        {
            STPush(&ps,s[i]);
        }
        else//右括号与栈顶元素进行匹配
        {
            if(STEmpty(&ps))//栈中为空，说明括号数量不匹配
            {
                return false;
            }
            else if((STTop(&ps)=='('&&s[i]!=')')||
                    (STTop(&ps)=='['&&s[i]!=']')||
                    (STTop(&ps)=='{'&&s[i]!='}'))//栈中不为空，但括号样式不匹配
            {
                return false;
            }
            else//匹配成功，栈顶元素出栈
            {
                STPop(&ps);
            }
        }
    }
    if(STEmpty(&ps))//全部遍历完之后，栈中为空，说明全部匹配成功
    {
        return true;
    }
    else//栈中不为空，说明数量不匹配
    {
        return false;
    }
	STDestroy(&ps);
}

 运行结果：

用栈实现队列：

题目描述：

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。

 首先要知道栈的特点是“先入后出”，因为此特点，把栈1中的数据移动到栈2中时，数据的顺序会倒过来，如下：

数据入栈顺序是1、2、3、4，此时再从栈2中执行出栈操作，数据出栈顺序也是1、2、3、4，可以满足队列“先入先出”的功能，因此我们不妨把一个栈专门同来进数据（push），另一个栈专门用来出数据（pop）。 

 每次进数据都压入push栈，出数据都从pop栈出，若pop栈为空，则把push栈的数据都压入pop栈后再出数据。

 代码如下：

typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;//栈顶
    int capacity;//容量
}ST;
typedef struct
{
    ST push;
    ST pop;
} MyQueue;

//初始化
void STInit(ST* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->capacity = 0;
    ps->top = 0;
}
//判空
bool STEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}
//销毁
void STDestroy(ST* ps)
{
    free(ps->a);
    ps->a = NULL;
    ps->capacity = 0;
    ps->top = 0;
}
//入栈
void STPush(ST* ps, STDataType x)
{
    assert(ps);
    if (ps->capacity == ps->top)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDataType* p = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
        ps->a = p;
        ps->capacity = newcapacity;
    }
    ps->a[ps->top] = x;
    ps->top++;
}

//出栈
void STPop(ST* ps)
{
    assert(ps);
    assert(ps->a);
    assert(!STEmpty(ps));
    ps->top--;
}
//取栈顶元素
STDataType STTop(ST* ps)
{
    assert(ps);
    assert(ps->a);
    assert(!STEmpty(ps));
    return ps->a[ps->top - 1];
}
//创建我的队列
MyQueue* myQueueCreate()
{
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->push);
    STInit(&obj->pop);
    return obj;
}
//入队
void myQueuePush(MyQueue* obj, int x)
{
    STPush(&obj->push, x);
}
//出队
int myQueuePop(MyQueue* obj)
{
    if (STEmpty(&obj->pop))
    {
        while (!STEmpty(&obj->push))
        {
            STDataType x = STTop(&obj->push);
            STPop(&obj->push);
            STPush(&obj->pop, x);
        }
    }
    STDataType front = STTop(&obj->pop);
    STPop(&obj->pop);
    return front;
}
//取队头
int myQueuePeek(MyQueue* obj)
{
    if (STEmpty(&obj->pop))
    {
        while (!STEmpty(&obj->push))
        {
            STDataType x = STTop(&obj->push);
            STPop(&obj->push);
            STPush(&obj->pop, x);
        }
    }
    STDataType front = STTop(&obj->pop);
    return front;
}
//我的队列判空
bool myQueueEmpty(MyQueue* obj)
{
    return (STEmpty(&obj->push) && STEmpty(&obj->pop));
}
//销毁我的队列
void myQueueFree(MyQueue* obj)
{
    STDestroy(&obj->push);
    STDestroy(&obj->pop);
    free(obj);
}

运行结果：

用队列实现栈：

题目描述：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

  • 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。

首先要知道队列的特点是“先进先出”，因为此特点，将队列1中的数据移动到队列2中时，数据的顺序不会变，如下：

 数据的从队列1进队顺序是1、2、3、4，如直接从队列2出队，则出队顺序也是1、2、3、4，无法满足栈的“先进后出”的特点。因此，想要通过队列实现栈，要始终保证至少一个队列为空（若两个队列都为空，则只能执行判空和压入数据的操作），这样在出数据时，把不为空队列（假设有n个数据）的前n-1个数据移动到空队列中，再出最后一个数据，这样不断在两个队列之间导数据，就能实现把后入的数据先出出去，而想要压入数据时，直接在非空的队列队尾直接插入即可，这样就能实现栈“先进后出”的特点。

 代码如下：

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

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;
typedef struct
{
	Que p1;
	Que p2;
} MyStack;
//判空 ：空返回1，非空返回0
bool QueueEmpty(Que* pq)
{
	assert(pq);
	return pq->head == NULL;
}
//初始化
void QueueInit(Que* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}
//销毁
void QueueDestroy(Que* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* p = cur->next;
		free(cur);
		cur = p;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}
//入队
void QueuePush(Que* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		pq->head = newnode;
		pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}
//出队
void QueuePop(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//要有数据
	if (pq->head->next == NULL)//只有一个节点
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	else
	{
		QNode* cur = pq->head->next;
		free(pq->head);
		pq->head = cur;
	}
	pq->size--;
}
//取队头
QDataType QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}
//取队尾
QDataType QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}
//有效数据
int QueueSize(Que* pq)
{
	assert(pq);
	return pq->size;
}
//创建我的栈
MyStack* myStackCreate()
{
	MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
	QueueInit(&obj->p1);
	QueueInit(&obj->p2);
	return obj;
}
//入栈
void myStackPush(MyStack* obj, int x)
{
	if (!QueueEmpty(&obj->p1))
	{
		QueuePush(&obj->p1, x);
	}
	else
	{
		QueuePush(&obj->p2, x);
	}
}
//出栈
int myStackPop(MyStack* obj)
{
	QDataType top = 0;
	if (!QueueEmpty(&obj->p1))
	{
		while (QueueSize(&obj->p1) > 1)
		{
			QDataType a = QueueFront(&obj->p1);
			QueuePop(&obj->p1);
			QueuePush(&obj->p2, a);
		}
		top = QueueFront(&obj->p1);
		QueuePop(&obj->p1);
	}
	else
	{
		while (QueueSize(&obj->p2) > 1)
		{
			QDataType a = QueueFront(&obj->p2);
			QueuePop(&obj->p2);
			QueuePush(&obj->p1, a);
		}
		top = QueueFront(&obj->p2);
		QueuePop(&obj->p2);
	}
	return top;
}
//取栈顶
int myStackTop(MyStack* obj)
{
	if (!QueueEmpty(&obj->p1))
	{
		return QueueBack(&obj->p1);
	}
	else
	{
		return QueueBack(&obj->p2);
	}
}
//判空
bool myStackEmpty(MyStack* obj)
{
	return (QueueEmpty(&obj->p1) && QueueEmpty(&obj->p2));
}
//销毁我的栈
void myStackFree(MyStack* obj)
{
	QueueDestroy(&obj->p1);
	QueueDestroy(&obj->p2);
	free(obj);
}

运行结果：

wlaa
关注
  • 30
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 18
    评论
oj题.zip
10-18
每一道题目都可能包含多种解题策略，如动态规划、贪心算法、回溯、深度优先搜索、广度优先搜索、链表操作、二叉树操作、字符串处理、图论以及基本的数据结构如数组、栈、队列、哈希表等。通过深入研究这些解决方案，...
程序设计基础 OJ 题库 NUIST
10-22
在OJ题库中，常见的数据结构包括数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树等）、哈希表等。理解并熟练运用这些数据结构可以有效地组织和操作数据，实现高效的算法。 在NUIST的"程序设计基础"课程中，...
栈和队列oj题
weixin_67595436的博客
08-11 242
225. 用队列实现栈 232. 用栈实现队列 622. 设计循环队列 补录一些题目
栈和队列 OJ题
jiejiezuishuai的博客
08-09 198
栈和队列 OJ题
栈和队列Oj习题
qq_52699147的博客
03-29 435
顺序栈 #include<bits/stdc++.h> using namespace std; const int StackSize = 5; //顺序栈的最大长度（请勿改动） template <class T> //定义模板类SeqStack class SeqStack { public: SeqStack(); //构造函数，栈的初始化 ~SeqStack(); //析构函数 void Pus
栈和队列OJ题：LeetCode--232.用栈实现队列
Yikefore的博客
05-20 1345
LeetCode--232.用栈实现队列：详细题解以及图解和完整代码。
栈和队列OJ题详解
2301_81154519的博客
05-26 692
栈和队列OJ题详解
【栈和队列OJ题】
2302_78420373的博客
07-11 1097
当字符串遍历完后，检测栈是否为空，若为空，则字符串有效，若不为空，说明有前括号未匹配，字符串无效。当需要进行出栈操作时，将不为空的队列中的数据导入空队列，仅留下一个数据，这时将这个数据返回并且删除即可。：环形队列的队尾不能像常规队列中队尾一样指向最后一个数据，如果这样的话，我们将不能区别环形队列的状态是空还是满，因为此时队头和队尾都指向同一个位置。：使用两个栈，第一个栈只用于数据的输入，第二个栈只用于数据的输出。的顺序出队列，我们可以先入一个栈，然后将第一个栈中的数据一个一个导入到第二个栈，输入即可。
栈和队列OJ题讲解
2303_81373308的博客
05-22 918
队列实现栈、栈实现队列、循环队列OJ题讲解
数据结构——栈和队列OJ题
2301_81888634的博客
07-30 688
是不是“有点意思”？敬请期待“二叉树‘~
栈和队列oj题自测
weixin_67401157的博客
03-20 325
栈和队列oj题自测
南阳理工oj离线题库
05-14
2. 数据结构与算法：题库中的题目可能会涉及各种数据结构，如数组、链表、栈、队列、树、图等，以及各种算法，如排序、搜索、动态规划、贪心算法等。用户可以通过解答这些题目来巩固和提升这些基础知识。 3. 编程...
平顶山学院OJ试题离线版
05-14
2. **数据结构**：涉及数组、链表、栈、队列、树（如二叉树、AVL树、红黑树等）、图、哈希表等。掌握这些数据结构能帮助解冑复杂的问题，并优化程序的运行效率。 3. **操作系统**：涵盖进程管理、内存管理、文件...
LeetCode:LeetCode OJ 题库
05-17
4. **滑动窗口最大值（239）**：此题考察的是数组处理和滑动窗口的概念。任务是在一个数组中找到每个可能窗口的最大值。可以利用双端队列（deque）来实现，保持队列中元素的顺序，同时维护窗口内的最大值。 这些...
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 666
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构----链表
新手嵌入式学习的博客
08-16 1181
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
数据结构：栈
最新发布
2301_80744520的博客
08-17 325
顺序栈的表示存储方式：利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。栈底一般在低地址。top：指示栈顶元素位置base：指示栈底元素位置stacksize：表示栈的最大容量接下来，我们用更详细的一幅图来描述顺序栈：起始状态，top和base都指向0的位置，此时是空栈：base==top，且栈的容量stacksize=4。接下来为空的栈添加元素（入栈），将新的元素添加到top所指位置，再将top移向下一位置，我们最终可以观察到top并没有指向D，而是栈的外面，即4的位置。
uva1586分子量（Molar Mass,ACM/ICPC Danang 2007）
2301_80844586的博客
08-14 233
然后代码具体要考虑i++每次进行i++自动i++这样避免算完字母后碰到数字然后会多算一次字母。就是一位算数字后i++如果【i+2】就是匹配到两位数的话再次i++；这样可以有效避免数字越界（你可以好好思考一下）如果都没有就是1直接定义1即可。第一个是有四个字母然后把for循环中匹配到的字母进行确认到z里面后面进行。第二的大逻辑就行下面的if那个三大判断条件第一个是一位数并且是。也是改了小两天，然后说一下核心代码逻辑两大块的核心。就是没有数字的就是1的。
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值