【栈和队列】算法题 ---- 力扣

已于 2024-07-23 23:27:41 修改
阅读量1.3k 收藏 62
点赞数 77
分类专栏： 【C语言】数据结构 文章标签： leetcode 算法 c语言
于 2024-07-21 22:08:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LH__1314/article/details/140530553
版权

        通过前面栈和队列的学习，现在来看这些算法题目

一、有效的括号

        本题让判断括号是否有效

第一眼看可能没一点思路，但仔细分析一下；

        我们学习过栈数据结构，知道栈先进后出的原则，那我们就可以使用啊；把题目的左括号存储起来，让右括号跟左括号一一比较。

思路：

        遍历字符串，遇到左括号就括号入栈，遇到右括号就与栈顶数据进行对比，如果配对就继续；如果不配对，就返回false

画图分析：

  现在有这样的括号字符串

        遍历字符串，第一个是  {  左括号，就入栈

        ps接着遍历， [  依然是左括号，入栈

        ps接着遍历，  (  还是左括号，入栈

        ps接着遍历，  )  是右括号，与栈顶数据进行比较，括号匹配，出栈

        ps接着遍历，  ]  是右括号，与栈顶数据比较，括号匹配，出栈

        ps接着遍历，  }  是右括号，与栈顶数据进行比较，括号匹配，出栈

        ps遍历完字符串，再判断栈是否为空？如果为空，就代表所以括号都匹配了；如果栈不为空，括号就不匹配。

        此外，再遍历过程中，有依次括号不匹配就要直接返回false

力扣题代码如下：

typedef char SType;
typedef struct Stack {
    SType* arr;
    int size; // 栈顶
    int num;  // 空间大小
} Stack;

// 初始化
void STInit(Stack* ps) {
    assert(ps);
    ps->arr = NULL;
    ps->size = ps->num = 0;
}
// 判断栈是否为空
bool STEmpty(Stack* ps) {
    assert(ps);
    return ps->size == 0;
}
// 入栈
void STPush(Stack* ps, SType x) {
    assert(ps);
    // 判断空间大小是否足够
    if (ps->num <= ps->size) {
        int newnum = (ps->num == 0) ? 4 : 2 * ps->num;
        SType* tmp = (SType*)realloc(ps->arr, newnum * sizeof(Stack));
        if (tmp == NULL) {
            perror("realloc filed");
            exit(1);
        }
        ps->arr = tmp;
        ps->num = newnum;
    }
    ps->arr[ps->size++] = x;
}
// 出栈
void STPop(Stack* ps) {
    assert(ps);           // 不能传NULL
    assert(!STEmpty(ps)); // 栈不能为空
    ps->size--;
}
// 取栈顶数据
SType STtop(Stack* ps) {
    assert(ps);           // 不能传NULL
    assert(!STEmpty(ps)); // 栈不能为空
    return ps->arr[ps->size - 1];
}
// 获取栈中数据个数
int STSize(Stack* ps) {
    assert(ps);
    return ps->size;
}
// 栈的销毁
void STDesTroy(Stack* ps) {
    assert(ps);
    if (ps->arr)
        free(ps->arr);
    ps->arr = NULL;
    ps->size = ps->num = 0;
}

bool isValid(char* s) {
    Stack arr;
    // 初始化
    STInit(&arr);
    char* ps = s;
    while (*ps != '\0') {
        if (*ps == '(' || *ps == '[' || *ps == '{') {
            // 入栈
            STPush(&arr, *ps);
        } else {
            // 取栈顶数据
            if (STEmpty(&arr)) {
                return false;
            }
            char ch = STtop(&arr);
            if ((ch == '(' && *ps == ')') || (ch == '[' && *ps == ']') ||
                (ch == '{' && *ps == '}')) {
                STPop(&arr);
            } else {
                return false;
            }
        }
        ps++;
    }
    if (STEmpty(&arr)) // 栈为空
    {
        return true;
    }
    return false;
}

二、用队列实现栈

        使用队列来实现栈，我们直到，队列是先进先出，而栈是先进后出。这里我们需要用两个队列来实现栈的相关操作

思路：

        保证两个队列中有一个为空，再两个队列之间来回导入导出数据。

        入栈：往不为空的队列里面插入数据

        出栈：找到不为空的队列，将size-1个数据导入到另一个队列，最后剩余的一个数据，就是要出栈的数据

        取栈顶元素：找到不为空的队列，取队尾元素即可

假设依次插入了1，2，3三个数据，现在要出栈

        将q1中数据size-1（2个）导入到q2中。

        现在q1当中剩余的数据就是要出栈的数据（即栈顶）。这样就满足了栈先进先出的特点。

力扣题代码如下：

typedef int QType;
typedef struct QueueNode // 队列节结构
{
    QType data;
    struct QueueNode* next;
} QueueNode;
typedef struct Queue // 队列结构
{
    int size;         // 队列中的数据个数
    QueueNode* phead; // 队头
    QueueNode* ptial; // 队尾
} Queue;

// 初始化
void QueueInit(Queue* pq) {
    assert(pq);
    pq->phead = pq->ptial = NULL;
    pq->size = 0;
}
// 判断队列是否为空
bool QueueEmpty(Queue* pq) {
    assert(pq);
    return pq->size == 0;
}
// 入队列--从队尾插入数据
void QueuePush(Queue* pq, QType x) {
    assert(pq);
    QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
    newnode->data = x;
    newnode->next = NULL;
    if (QueueEmpty(pq)) // 队列为空
    {
        pq->phead = pq->ptial = newnode;
    } else { // 队列不为空
        pq->ptial->next = newnode;
        pq->ptial = newnode;
    }
    pq->size++;
}
// 出队列--从对头删除数据
void QueuePop(Queue* pq) {
    assert(pq);              // 不能传NULL
    //assert(!QueueEmpty(pq)); // 队列不能为空
    QueueNode* del = pq->phead;
    pq->phead = pq->phead->next;
    if (pq->size == 1) // 队列只有一个节点
    {
        pq->ptial = NULL;
    }
    pq->size--;
    free(del);
    del = NULL;
}
// 取队头数据
QType QueueFront(Queue* pq) {
    assert(pq);              // 不能传NULL
    //assert(!QueueEmpty(pq)); // 队列不能为空
    return pq->phead->data;
}
// 取队尾数据
QType QueueBack(Queue* pq) {
    assert(pq);              // 不能传NULL
    //assert(!QueueEmpty(pq)); // 队列不能为空
    return pq->ptial->data;
}
// 获取队列数据个数
int QueueSize(Queue* pq) {
    assert(pq); // 不能传NULL
    return pq->size;
}
// 销毁队列
void QueueDesTroy(Queue* pq) {
    assert(pq);              // 不能传NULL
    //assert(!QueueEmpty(pq)); // 队列不能为空
    QueueNode* pcur = pq->phead;
    while (pcur) {
        QueueNode* del = pcur;
        pcur = pcur->next;
        free(del);
        del = NULL;
    }
    pq->phead = pq->ptial = NULL;
    pq->size = 0;
}

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

MyStack* myStackCreate() {
    MyStack* Qst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&Qst->q1);
    QueueInit(&Qst->q2);
    return Qst;
}

void myStackPush(MyStack* obj, int x) {
    // 往不为空的队列中插入数据
    if (QueueEmpty(&obj->q1)) {
        QueuePush(&obj->q2, x);
    } else {
        QueuePush(&obj->q1, x);
    }
}

int myStackPop(MyStack* obj) {
    // 先找到不为空的队列
    Queue* empq = &obj->q1;
    Queue* noneq = &obj->q2;
    if (!(QueueEmpty(&obj->q1))) // 如果q1不为空
    {
        empq = &obj->q2;
        noneq = &obj->q1;
    }
    //empq --  空队列
    //noneq --  非空队列
    while(QueueSize(noneq) > 1) {
        // 将noneq队列的数据导入到empq中去
        QueuePush(empq, QueueFront(noneq));
        QueuePop(noneq);
    }
    int ret = QueueFront(noneq);
    QueuePop(noneq);
    return ret;
}

int myStackTop(MyStack* obj) {
    if(QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q2);
    }else{
        return QueueBack(&obj->q1);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    free(obj);
    obj = NULL;
}

三、用栈实现队列

        上一个题让我们用队列来实现栈，这个用两个栈来实现队列。

定义两个栈

思路：

        往PushST中插入数据，再将数据导入到PopST中，出栈即可；

        入队列：往PushST中插入数据

        出队列：判断栈PopST是否为空？如果PopST栈为空，就将栈PushST中数据导入到栈PopST中去，再让栈PopST出栈操作；如果不为空，直接让栈PopST出栈操作即可。

        取队头数据：和出队列操作一样，只是不需要出栈操作，只取数据

分析：

        假设依次插入了1，2，3三个数据，现在出栈一次，再插入一个数据4，最后取队头数据，依次出栈。

        出栈一次，PopST为空，就将PushST中数据导入到PopST中去。

依次导入

        出栈；

再插入数据4

取队头数据：

最后依次出队列

现在，PopST栈为空，就要先将PushST中数据先导入到PopST中。

再出队列

力扣题代码如下：

typedef int SType;
typedef struct Stack
{
	SType* arr;
	int size;  //栈顶
	int num;   //空间大小
}Stack;
//初始化
void STInit(Stack* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->size = ps->num = 0;
}
//判断栈是否为空
bool STEmpty(Stack* ps)
{
	assert(ps);
	return ps->size == 0;
}
//入栈
void STPush(Stack* ps, SType x)
{
	assert(ps);
	//判断空间大小是否足够
	if (ps->num <= ps->size)
	{
		int newnum = (ps->num == 0) ? 4 : ps->num * 2;
		SType* tmp = (SType*)realloc(ps->arr, newnum * sizeof(Stack));
		if (tmp == NULL)
		{
			perror("realloc filed");
			exit(1);
		}
		ps->arr = tmp;
		ps->num = newnum;
	}
	ps->arr[ps->size++] = x;
}
//出栈
void STPop(Stack* ps)
{
	assert(ps); //不能传NULL
	assert(!STEmpty(ps));  //栈不能为空
	ps->size--;
}
//取栈顶数据
SType STtop(Stack* ps)
{
	return ps->arr[ps->size - 1];
}
//获取栈中数据个数
int STSize(Stack* ps)
{
	assert(ps);
	return ps->size;
}
//栈的销毁
void STDesTroy(Stack* ps)
{
	assert(ps);
	if (ps->arr)
		free(ps->arr);
	ps->arr = NULL;
	ps->size = ps->num = 0;
}


typedef struct {
    Stack s1;
    Stack s2;
} MyQueue;

//初始化
MyQueue* myQueueCreate() {
    MyQueue* Queue=(MyQueue*)malloc(sizeof(MyQueue));
    STInit(&Queue->s1);
    STInit(&Queue->s2);
    return Queue;
}
//插入数据
void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    STPush(&obj->s1, x);
}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    if(STEmpty(&obj->s2))
    {
        //把s1中数据导入到s2
        while(!STEmpty(&obj->s1))
        {
            STPush(&obj->s2,STtop(&obj->s1));
            STPop(&obj->s1);
        }
    }
    int ret=STtop(&obj->s2);
    STPop(&obj->s2);
    return ret;
}

int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->s2))
    {
        //把s1中数据导入到s2
        while(!STEmpty(&obj->s1))
        {
            STPush(&obj->s2,STtop(&obj->s1));
            STPop(&obj->s1);
        }
    }
    return STtop(&obj->s2);
}

bool myQueueEmpty(MyQueue* obj) {
    return (STEmpty(&obj->s1)) && (STEmpty(&obj->s2));
}

void myQueueFree(MyQueue* obj) {
    if(obj)
        free(obj);
    obj=NULL;
}

四、设计循环队列

        设计循环队列，这里使用数组来设计

这里会设计到的一些问题：

        插入数据，如何判断空间是否满了？       

这里多申请一个空间，便于判断空间是否满了

        删除数据，如何去删？

这里，删除front指向的数据，就是队头数据

详细代码如下：


typedef struct {
    int* arr;
    int front;
    int rear;
    int num;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    pq->arr = malloc((k + 1) * sizeof(int));
    pq->front = pq->rear = 0;
    pq->num = k;
    return pq;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {

    return (obj->rear == obj->front);
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear + 1) % (obj->num + 1) == obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {

    if (myCircularQueueIsFull(obj)) // 队列满了
    {
        return false;
    }
    // 插入数据
    obj->arr[obj->rear++] = value;
    obj->rear %= (obj->num + 1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) {
        return false;
    }
    obj->front++;
    obj->front %= (obj->num + 1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    return obj->arr[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    int ret=obj->rear-1;
    if(obj->rear==0)
    {
        ret=obj->num;
    }
    return obj->arr[ret];
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->arr);
    free(obj);
    obj = NULL;
}

感谢各位大佬支持并指出问题，

                        如果本篇内容对你有帮助，可以一键三连支持以下，感谢支持！！！

努力学习的小廉
关注
  • 77
    点赞
  • 踩
  • 62
    收藏
    觉得还不错? 一键收藏
  • 42
    评论
专栏目录
力扣算法-互联网公司常见算法面试题
03-02
这个压缩包文件包含的是Java版本的力扣算法题目解决方案，意味着你可以通过阅读和理解这些代码来深入了解Java编程语言在处理算法问题时的应用。 1. **数据结构**：在LeetCode中，常见的数据结构包括数组、链表、栈...
leetcode题库-LeetCode:力扣题库
06-29
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为提升算法技能和准备技术面试而设计。它包含了各种难度级别的编程问题，涵盖了多种编程语言，如Java、Python、C++等。LeetCode题库提供了丰富的算法题目，...
栈和队列算法题 - 设计循环队列
黎相思的博客
07-21 237
- 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。. - 力扣（LeetCode）如何判断队列是满的还是空的?
栈和队列算法题 - 用栈实现队列
黎相思的博客
07-21 225
- 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。. - 力扣（LeetCode）
栈和队列算法题 - 有效的括号
黎相思的博客
07-19 180
处理只有一个左括号的问题,左括号入栈,然后字符串遍历完成,然后直接返回true，所i有字符串遍历完成之后我们还要判断栈是否为空,如果不为空,那么就是在遍历字符串的时候没有比较以及出栈。如果只有一个右括号的话说明没有入栈,直接去取栈顶的元素,此时栈是空的,取元素会报断言错误。所有在取栈顶元素之前需要判断一下,栈不为空才能取栈顶的元素。. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。. - 力扣（LeetCode）
栈和队列算法题 - 用队列实现栈
黎相思的博客
07-20 279
注意:取栈顶元素的时候不出栈,也有意外这把size-1个元素导入到另一个队列中,就会导致这两个队列都不为空,但是在我们两个队列实现栈的操作中,我们有一个前提就是必须保证至少有一个队列为空。. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。. - 力扣（LeetCode）
js代码-力扣第七题
07-16
力扣（LeetCode）是程序员常用来练习编程技能的一个在线平台，它提供了各种算法和数据结构问题供用户解决。在本压缩包中，我们有两个文件：`main.js`和`README.txt`，它们可能包含了针对力扣第七题的JavaScript解决...
js代码-力扣第六题
07-16
力扣（LeetCode）是程序员常用来练习编程技能的一个在线平台，它提供了各种算法和数据结构问题供用户解决。在本案例中，我们关注的是力扣的第六题，不过具体的题目描述没有提供。通常，力扣的题目编号与其在平台上的...
javalruleetcode-leetcode:力扣算法题解
06-29
力扣算法解题，java语言 题解 简单 序号(力扣题序号) 题名 题解 两数之和 整数反转 相同的树 最长回文串 链表的中间节点 三维形体的表面积 卡牌分组 可以被一步捕获的棋子数 不用加号的加法 最小的K个数 不用加减...
力扣 102题 二叉树的层次遍历 记录
m0_49800270的博客
07-22 654
队列是一种先进先出（FIFO）的数据结构，非常适合于层序遍历，因为我们总是希望按照从树的上层到下层的顺序处理节点。队列操作：使用一个队列来管理待处理的树节点。队列的先进先出特性保证了树的每一层都按照从左到右的顺序被处理。
力扣202.快乐数
最新发布
gyj215500的博客
07-25 215
主要是用到了鸽巢原理，最后他们一定会重合，我们只需要判断类似，链表的成环相遇的时候是不是1就行了。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 277
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
C++ | Leetcode C++题解之第275题H指数II
Ddddddd_158的博客
07-23 354
C++ | Leetcode C++题解之第275题H指数II
leetcode 69. x 的平方根
m0_49013185的博客
07-24 241
可以使用二分查找法或牛顿迭代法来实现 LeetCode 问题。下面是使用二分查找法和牛顿迭代法的 C++ 实现。
leetcode4 -- 寻找两个正序数组的中位数
m0_65985318的博客
07-23 222
先将两数组合并，然后利用sort排序算法，对数组进行从小到大的排序，根据总长度是奇数或者偶数来决定中位数的位置。合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5。合并数组 = [1,2,3] ，中位数 2。请你找出并返回这两个正序数组的。的正序（从小到大）数组。算法的时间复杂度应该为。
leetcode-104. 二叉树的最大深度
曼巴的博客
07-23 355
3）再逐渐往回返，每个当前层的长度为左右子树长度的较大值+1。是指从根节点到最远叶子节点的最长路径上的节点数。2）遍历到底部（叶子结点）时，当前层的长度为1。4）如果当前没节点，返回0。1）递归地从上向下走。
Leetcode 17. 电话号码的字母组合
li_yizhixiaowukong的博客
07-24 333
输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。输入：digits = “23”输出：[“a”,“b”,“c”]输入：digits = “2”输入：digits = “”看了下 腐烂的橘子 的题解。，感觉还挺麻烦，之后研究下。
Leetcode—343. 整数拆分【中等】
Atticus的博客
07-22 212
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
javascript力扣算法题库
10-12
好的，你想了解 JavaScript力扣算法题库，这是一个非常好的主题。JavaScript力扣算法题库是一个包含各种算法问题的在线平台，它提供了许多有趣的问题，可以帮助你提高你的编程技能。你可以在这个平台上找到各种难度级别的问题，从简单的问题到复杂的问题都有。你可以通过解决这些问题来提高你的编程技能和算法思维能力。
评论 42
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值