栈和队列的实现以及相关题目

最新推荐文章于 2024-09-14 22:25:23 发布
最新推荐文章于 2024-09-14 22:25:23 发布
阅读量57 收藏 3
点赞数 5
分类专栏： C语言 算法 数据结构与算法 文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tk333918/article/details/134542543
版权
本文介绍了栈和队列的数据结构概念，重点展示了如何使用C语言通过数组和链表实现栈的插入、删除和查看操作，以及队列的相似操作，包括队列的先进先出特性。还提供了栈和队列在实际问题中的应用实例，如有效括号验证和用栈模拟队列等。
摘要由CSDN通过智能技术生成

栈

什么是栈？

栈是一种特殊的线性表，它只可以在固定的一端进行插入和删除数据的操作。
栈顶：进行插入和删除操作的一端；
栈底：与栈顶相对，确定了栈顶，栈底就确定了；
栈的特点：先进后出或者后进先出（这很重要）；

如何实现栈？

实现栈一般使用数组或者链表两种方式。推荐使用数组，因为不需要考虑数据的移动，且查找数据方便。
我将用数组的形式去实现（使用的语言为C语言）

代码实现栈

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

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;      // 标识栈顶位置的
	int capacity;
}ST;
//栈的初始化
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->capacity = 0;
	// 表示top指向栈顶元素的下一个位置
	pst->top = 0;
}
//栈的销毁
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

// 栈顶插入删除
void STPush(ST* pst, STDataType x)
{
	assert(pst);

	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		pst->a = tmp;
		pst->capacity = newcapacity;
	}

	pst->a[pst->top] = x;
	pst->top++;
}
//删除栈顶元素
void STPop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);

	pst->top--;
}
//取栈顶元素
STDataType STTop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);

	return pst->a[pst->top - 1];
}
//栈的判空
bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}
//栈长
int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}

队列

什么是队列？

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作；
队头：进行删除数据操作的一端；
队尾：进行插入数据操作的一端；
特点：先进先出；

如何实现队列？

队列的实现也可以使用数组和链表，不过这里更加推荐链表，因为队列在队头删除数据，对于数组来说就需要移动数据，效率不高。
我将用链表实现队列（使用语言为C语言）

代码实现队列

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

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

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;
//队列的初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
//队列的销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
//入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->val = x;
	newnode->next = NULL;

	if (pq->ptail == NULL)
	{
		pq->ptail = pq->phead = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}

	pq->size++;
}

// 出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	// 
	assert(pq->phead);

	QNode* del = pq->phead;
	pq->phead = pq->phead->next;
	free(del);
	del = NULL;

	if (pq->phead == NULL)
		pq->ptail = NULL;

	pq->size--;
}

//取队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	// 
	assert(pq->phead);

	return pq->phead->val;
}
//取队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	// 
	assert(pq->ptail);

	return pq->ptail->val;
}
//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->phead == NULL;
}
//求队列长度
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

栈和队列的相关题目

1.有效的括号

（1）.题目链接：link

（2）.代码实现

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		// 标识栈顶位置的
	int capacity;
    int size;
}ST;

void STInit(ST* pst)
{
    assert(pst);
    pst->a=NULL;
    pst->top=0;
    pst->capacity=0;
    pst->size=0;
}
void STDestroy(ST* pst)
{
    assert(pst);
    free(pst->a);
    pst->a=NULL;
    pst->top=pst->capacity=0;
    pst->size=0;
}

// 栈顶插入
void STPush(ST* pst, STDataType x)
{
    assert(pst);
    if(pst->top==pst->capacity)
    {
        int newcapacity=pst->capacity==0?4:2*pst->capacity;
        STDataType* temp=(STDataType*)realloc(pst->a,sizeof(STDataType)*newcapacity);
        if(temp==NULL)
        {
            perror("realloc fail");
            return ;
        }
        pst->capacity=newcapacity;
        pst->a=temp;
    }
    pst->a[pst->top]=x;
    pst->top++;
    pst->size++;
}
//
void STPop(ST* pst)
{
   assert(pst);
   assert(pst->top>0);
   pst->top--;
   pst->size--;
}
STDataType STTop(ST* pst)
{
    assert(pst);
    assert(pst->top>0);
    return pst->a[pst->top-1];
}

bool STEmpty(ST* pst)
{
    assert(pst);
    return pst->top==0;
}
int STSize(ST* pst)
{
    assert(pst);
    return pst->size;
}

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;
    }
    if(STEmpty(&st))
    {
        STDestroy(&st);
        return true;
    }
    else
    {
         STDestroy(&st);
        return false;
    }
}

2.用队列实现栈

（1）题目链接：link

（2）代码实现：

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

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->val = x;
	newnode->next = NULL;

	if (pq->ptail == NULL)
	{
		pq->ptail = pq->phead = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}

	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	// 
	assert(pq->phead);

	QNode* del = pq->phead;
	pq->phead = pq->phead->next;
	free(del);
	del = NULL;

	if (pq->phead == NULL)
		pq->ptail = NULL;

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	// 
	assert(pq->phead);

	return pq->phead->val;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	// 
	assert(pq->ptail);

	return pq->ptail->val;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->phead == NULL;
}

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

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

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

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

int myStackPop(MyStack* obj) 
{
    Queue* emptyq=&obj->q1;
    Queue* nonemptyq=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyq=&obj->q2;
        nonemptyq=&obj->q1;
    }
    while(QueueSize(nonemptyq)>1)
    {
        QueuePush(emptyq,QueueFront(nonemptyq));
        QueuePop(nonemptyq);
    }
    int top=QueueFront(nonemptyq);
    QueuePop(nonemptyq);
    return top;
}

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

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

void myStackFree(MyStack* obj) 
{
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

3.用栈实现队列

（1）题目链接：link

(2）代码实现：

typedef int STDataType;

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

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

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

	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

// 栈顶插入删除
void STPush(ST* pst, STDataType x)
{
	assert(pst);

	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		pst->a = tmp;
		pst->capacity = newcapacity;
	}

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

void STPop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);

	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);

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

bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}


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


MyQueue* myQueueCreate()
{
   MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
   STInit(&obj->pushst);
   STInit(&obj->popst);
   return obj;
}

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

int myQueuePop(MyQueue* obj) 
{
    int front=myQueuePeek(obj);
    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);
        }
        
    }
    return STTop(&obj->popst);
}

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

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);
    free(obj);
    
}
栈和队列_入门oj题目练习：1用队列实现栈2用栈实现队列
Da_moLL的博客
06-11 303
@[TOC]栈和队列_入门oj题目练习 #用队列实现栈 #用栈实现队列 #设计循环队列 栈和队列_入门oj题目练习用队列实现栈用栈实现队列设计循环队列1:队列实现栈总结： 用队列实现栈 用栈实现队列 设计循环队列 1:队列实现栈 link. *题目要求：请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通队列的全部四种操作（push、top、pop 和 empty）。 实现 MyStack 类： void push(int x) 将元素 x 压入栈顶。 int pop() 移除并返回栈顶元素。 i
LeetCode刷题：栈和队列的相关题目
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
07-17 509
文章是跟着代码随想录的刷题路线来的，对里面的一些题目进行了总结
栈和队列(超详细Java实现)
热门推荐
qq_57735833的博客
07-30 1万+
可以看到,先入栈的元素要等后入栈的元素出栈后才能出栈,栈中的元素总是遵循后进先出LIFO（Last In First Out）的原则。生活中的例子:JVM : Java虚拟机Java标准库中提供的栈 可以看到，Stack继承了Vector，Vector是动态的顺序表,与ArrayList类似,不同的是,Vector是线程安全的.实现的方法 输出结果: 2. 入栈(push) 3. 出栈(pop) 4.获取栈顶元素(peek) 5.获取元素个数(getSize) 6.判断栈是否为空(isEm
数据结构——Java实现栈和队列
2301_77116754的博客
01-19 821
Java实现栈，Java实现队列，以数组为底层来实现栈和队列，232.用栈实现队列，225.用队列实现栈
LeetCode栈和队列经典例题
m0_70811813的博客
01-09 843
这里有四道关于栈和队列的经典题型
栈和队列OJ题：LeetCode--232.用栈实现队列
Yikefore的博客
05-20 1407
LeetCode--232.用栈实现队列：详细题解以及图解和完整代码。
栈和队列的实现和总结
m0_72873854的博客
11-23 1261
栈和队列的总结
C语言实现栈和队列及经典题目(附详细源码)
csdn_myhome的博客
01-15 744
C语言实现栈和队列(附详细源码)。
栈和队列实现的思路和代码
Javaxaiobai的博客
11-14 462
接下来我们要学习的两个数据结和前面的链表相比要简单很多了，我们主要讨论一下他们的主要性质和实现思路。
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2000
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
算法讲解014【入门】队列和栈入门题目-栈和队列相互实现.pptx
08-27
算法讲解014【入门】队列和栈入门题目-栈和队列相互实现
02-栈和队列.zip
01-31
栈与队列.pptx可能是课程的幻灯片，详细地展示了这两个数据结构的特性、操作以及相关算法的实现。幻灯片可能包含示例代码、图解和习题。 作业.txt可能包含了一些练习题目，要求学生实践栈和队列的操作，或者解决...
栈和队列的实现
12-17
这里展示一个基于动态数组的简单队列实现： ```cpp #include #include template class Queue { private: std::vector<T> elements; public: void enqueue(const T& item) { elements.push_back(item); } ...
设计栈和队列以及相互实现栈和队列
weixin_48252894的博客
01-20 491
一、设计循环队列(力扣622题： 设计循环队列) public class MyCircularQueue { private int[] elem; private int front; private int rear; public MyCircularQueue(int k) { this.elem = new int[k + 1]; } //入队（队尾入队） public boolean enQueue(int valu
计算左边（比自己小的元素）的最长距离
wniuniu_的博客
09-14 93
前言：一般做的题目都是使用单调栈来求出距离这个点最近的那个比这个数大或小的元素，但是如果是需要找到最远的那个元素呢？我们可以用到类似逆序对的思路，我们先进行排序从小到大，接着我们先处理左边，每次维护一个最小的下标。
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1128
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 545
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 393
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
leecode100题-双指针-三数之和
kian9one的博客
09-10 378
固定i，即可转换为寻找满足 nums[l]+nums[r]=−nums[i] 的三元组，因为不能包含重复的三元组，以下两个三元组只能取一个，而后我们再考虑其是否满足 nums[l]+nums[r]=−nums[i]。先对数组排序，设一非递减的数组示例和初始三指针位置及名字如下所示。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。移动指针的时候，需要规避连续的重复元素。答案中不可以包含重复的三元组。，判断是否存在三元组。
数据结构：栈和队列的概念、操作与实现
本节主要探讨了栈和队列的定义、特点以及它们的实现方式。 栈是一种特殊的线性表，遵循“后进先出”（LIFO）的原则，即最后被插入的元素最先被删除。栈的主要操作包括初始化栈、入栈（Push）、出栈（Pop）、获取...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值