leetcode栈和队列的相关题、有效的括号、用队列实现栈、用栈实现队列、设计循环队列等介绍

最新推荐文章于 2024-06-14 05:45:37 发布
最新推荐文章于 2024-06-14 05:45:37 发布
阅读量671 收藏 8
点赞数 11
分类专栏： 数据结构 文章标签： leetcode c语言 数据结构 队列 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Farewell_me/article/details/139245886
版权

文章目录

前言

leetcode栈和队列的相关题、有效的括号、用队列实现栈、用栈实现队列、设计循环队列等介绍

一、有效的括号

leetcode有效的括号
在这里插入图片描述


// 动态增长的栈
typedef char STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;


// 初始化栈
void STInit(ST* ps);

// 销毁栈
void STDestroy(ST* ps);

// 插入
void STPush(ST* ps, STDataType x);

// 出栈
void STPop(ST* ps);

// 检查是否为空
bool STEmpty(ST* ps);

// 获取栈顶元素
STDataType STTop(ST* ps);

//获取有效元素的个数
int STSize(ST* ps);


// 初始化栈
void STInit(ST* ps)
{
	assert(ps);

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("STInit malloc");
		return;
	}

	ps->top = 0; // top指的是栈顶元素的下一个位置
	//ps->top = -1; // top 指的是栈顶元素
	ps->capacity = 4;
}



// 销毁栈
void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a == NULL;

	ps->top = 0;
	ps->capacity = 0;
}



// 入栈
void STPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("STPush relloc");
			return;
		}

		ps->a = tmp;
		ps->capacity *= 2;
		
	}

	ps->a[ps->top] = x;
	ps->top++;
}


// 出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

	ps->top--;
}


// 检查是否为空
bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}



// 获取栈顶元素
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));


	return ps->a[ps->top - 1];
}



// 获取有效元素的个数
int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}


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

    while(*s)
    {
        if(*s == '(' || *s == '[' || *s == '{')
        {
            STPush(&st, *s);
        }
        else
        {
            if(STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }

            char top = STTop(&st);
            STPop(&st);

            if((*s == ')' && top != '(')
            || (*s == ']' && top != '[')
            || (*s == '}' && top != '{'))
            {
                STDestroy(&st);
                return false;
            }
        }
        s++;
    }

    bool ret = STEmpty(&st);

    STDestroy(&st);

    return ret;
}

二、用队列实现栈

leetcode用队列实现栈

在这里插入图片描述

typedef int QDataType;

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



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


// 初始化队列
void QInit(Queue* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;

}


// 销毁队列
void QDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;

	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}


// 入队列
void QPush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("QPush()::malloc()");
		return;
	}
	newnode->next = NULL;
	newnode->data = x;

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

// 出队列
void QPop(Queue* pq)
{
	assert(pq);
	assert(pq->head != NULL);

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* cur = pq->head;
		pq->head = cur->next;

		free(cur);
		cur = NULL;
	}
	pq->size--;
	
}



// 获取队列元素个数
int QSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}


// 判断队列是否为空
bool QEmpty(Queue* pq)
{
	assert(pq);

	return (pq->head == NULL && pq->tail == NULL);
}


// 找到队列的头元素
QDataType QFront(Queue* pq)
{
	assert(pq);
	assert(!QEmpty(pq));

	return (pq->head->data);
}


// 找到队列的尾元素
QDataType QBack(Queue* pq)
{
	assert(pq);
	assert(!QEmpty(pq));

	return (pq->tail->data);
}


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


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    if(pst == NULL)
    {
        perror("myStackCreate malloc");
        return NULL;
    }

    QInit(&pst->q1);
    QInit(&pst->q2);

    return pst;
}

void myStackPush(MyStack* obj, int x) {
    if(!QEmpty(&obj->q1))
    {
        QPush(&obj->q1, x);
    }
    else
    {
        QPush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;

    if(!QEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }

    while(QSize(nonempty) > 1)
    {
        QPush(empty, QFront(nonempty));
        QPop(nonempty);
    }

    int top = QFront(nonempty);
    QPop(nonempty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QEmpty(&obj->q1))
    {
        return QBack(&obj->q1);
    }
    else
    {
        return QBack(&obj->q2);
    }
}

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

void myStackFree(MyStack* obj) {
    QDestroy(&obj->q1);
    QDestroy(&obj->q2);

    obj = NULL;
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

三、 用栈实现队列

leetcode用栈实现队列

在这里插入图片描述

// 动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

// 初始化栈
void STInit(ST* ps);

// 销毁栈
void STDestroy(ST* ps);

// 插入
void STPush(ST* ps, STDataType x);

// 出栈
void STPop(ST* ps);

// 检查是否为空
bool STEmpty(ST* ps);

// 获取栈顶元素
STDataType STTop(ST* ps);

//获取有效元素的个数
int STSize(ST* ps);

// 初始化栈
void STInit(ST* ps)
{
	assert(ps);

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("STInit malloc");
		return;
	}

	ps->top = 0; // top指的是栈顶元素的下一个位置
	//ps->top = -1; // top 指的是栈顶元素
	ps->capacity = 4;
}



// 销毁栈
void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a == NULL;

	ps->top = 0;
	ps->capacity = 0;
}



// 入栈
void STPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("STPush relloc");
			return;
		}

		ps->a = tmp;
		ps->capacity *= 2;
		
	}

	ps->a[ps->top] = x;
	ps->top++;
}


// 出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

	ps->top--;
}


// 检查是否为空
bool STEmpty(ST* ps)
{
	assert(ps);

	return (ps->top == 0);
}



// 获取栈顶元素
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));


	return ps->a[ps->top - 1];
}



// 获取有效元素的个数
int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}


typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* tmp = (MyQueue*)malloc(sizeof(MyQueue));
    if(tmp == NULL)
    {
        perror("myQueueCreate malloc");
        return NULL;
    }

    STInit(&tmp->pushst);
    STInit(&tmp->popst);

    return tmp;
}

void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->pushst, x);
}

int myQueuePop(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst, STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }

    int front = STTop(&obj->popst);

    STPop(&obj->popst);
    return front;
}

int myQueuePeek(MyQueue* obj) {
        if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst, STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }

    int front = STTop(&obj->popst);

    return front;
}

bool myQueueEmpty(MyQueue* obj) {
    return (STEmpty(&obj->pushst) && STEmpty(&obj->popst));
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);

    free(obj);
    obj = NULL;
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

四、设计循环队列

leetcode设计循环队列

在这里插入图片描述


typedef struct {
    int* a;
    int Front;
    int Rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* tmp = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

    tmp->a = (int*)malloc(sizeof(int) * (k+1));
    tmp->Front = tmp->Rear = 0;
    tmp->k = k;

    return tmp;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return (obj->Front == obj->Rear);
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->Front == (obj->Rear + 1) % (obj->k + 1));
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    // 判断是否满了
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    // 没满
    obj->a[obj->Rear] = value;
    obj->Rear++;
    obj->Rear = obj->Rear % (obj->k + 1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    // 判断你是否为空
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }

    obj->Front = obj->Front % (obj->k + 1);
    obj->Front++;
    return true;
    
}

int myCircularQueueFront(MyCircularQueue* obj) {
    // 判断队列为空 返回 -1
    if(myCircularQueueIsEmpty(obj))
    {
        return - 1;
    }

    return obj->a[obj->Front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    // 判断队列为空 返回 -1
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }

    return obj->a[(obj->Rear-1 + (obj->k + 1)) % (obj->k + 1)];
}



void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a = NULL;
    obj->Front = obj->Rear = 0;
    obj->k = 0;
    free(obj);
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

总结

leetcode栈和队列的相关题、有效的括号、用队列实现栈、用栈实现队列、设计循环队列等介绍

Farewell_me
关注
  • 11
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode栈和队列 java
csf94的博客
02-16 432
括号匹配 Deque
leetcode232用栈实现队列 空间96%代码+思路
01-20
使用栈实现队列的下列操作： push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue....
栈和队列OJ题：LeetCode--232.用栈实现队列
Yikefore的博客
05-20 1260
LeetCode--232.用栈实现队列：详细题解以及图解和完整代码。
LeetCode栈和队列经典例题
m0_70811813的博客
01-09 709
这里有四道关于栈和队列的经典题型
栈和队列OJ题：LeetCode--225.用队列实现栈
Yikefore的博客
05-19 859
LeetCode--225.用队列实现栈：详细题解以及图解和完整代码。
栈和队列OJ题：LeetCode--20.有效的括号
Yikefore的博客
05-18 614
栈和队列OJ题：LeetCode--20.有效的括号：详细题解以及图解和完整代码
leetcode栈&队列&优先队列（上）之理论篇（Java实现）
ji_meng的博客
09-15 498
学习数据结构，需要先搞清楚自己语言是怎么实现的。栈与队列是每个学数据结构最早接触的数据结构，相信很多人对这两种数据结构的特性清楚地了解，但是也仅限于此。所以本文以leetcode习题为例，深入探索这两种数据结构，以及如何灵活运用这两种数据结构的思想，为下篇leetcode栈与队列实战篇（链接）铺垫。leetcode栈与队列（下）之实战篇（java实现）先进先出先进后出。
面试题09. 用两个栈实现队列【LeetCode剑指offer】
江璇Up
05-01 565
题目： 面试题09. 用两个栈实现队列 思路 两个栈，一个size（队列中数据的数量） 入队列直接压入栈1，并且size++； 出队列时，先判断size是否为0，若size 为 0，则说明队列空，返回-1； 否则直接取出栈2的栈顶元素，若栈2为空，则把栈1 的所有元素一次性出栈压入栈2，此时栈2，按顺序弹出则是队列出队列的顺序，先进先出；出队列时，要相应的的size–； 实现： class ...
【Leetcode刷题Python】232. 用栈实现队列
BetterBench的博客
06-01 220
使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：实现 MyQueue 类：void push(int x)将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean empty()如果队列为空，返回 true ；否则，返回 false注意：peek()和pop()的区别是，peek()不出栈，pop()要出栈。 （1）入队（push） 一个队列是 先入先出的，但一个栈是
【数据结构与算法】用队列实现栈&&用栈实现队列&&设计循环队列
joy.728的博客
10-18 1407
三道经典的OJ题：用队列实现栈、用栈实现队列和设计循环队列，点进来保证你能学会！！！
python入门-leetcode面试题解之第232题用栈实现队列.zip
05-31
python入门 python入门_leetcode面试题解之第232题用栈实现队列
java-leetcode面试题解Stack之第232题用栈实现队列-题解.zip
05-05
java java_leetcode面试题解Stack之第232题用栈实现队列_题解
Leetcode刷题（20）栈和队列的基本应用：用队列实现栈
01-20
题目分析： 这题主要考察对于栈和队列性质的理解，他们的本质不同就在于元素进入和弹出的顺序，完全相反。栈是 Last In First Out (LIFO), 队列是 Fisrt In First Out (FIFO), 实现起来有点变扭。 解法： class ...
python入门-leetcode面试题解之第225题用队列实现栈.zip
05-31
python入门 python入门_leetcode面试题解之第225题用队列实现栈
Golang | Leetcode Golang题解之第149题直线上最多的点数
weixin_66442839的博客
06-14 388
Golang | Leetcode Golang题解之第149题直线上最多的点数
【回溯】Leetcode 77. 组合【中等】
FLGB
06-11 263
你可以按 任何顺序 返回答案。
【代码随想录算法训练Day35】LeetCode 1005. K 次取反后最大化的数组和、LeetCode 134.加油站、LeetCode 135.分发糖果
qq_46121420的博客
06-11 234
贪心第三天
Java | Leetcode Java题解之第149题直线上最多的点数
最新发布
m0_57195758的博客
06-14 300
Java | Leetcode Java题解之第149题直线上最多的点数
leetcode 第102题 c语言实现
03-05
可以使用队列来实现二叉树的层序遍历，具体实现可以参考以下代码： ``` /** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值