【数据结构】栈和队列（有完整的模拟实现代码！）

已于 2024-09-28 12:36:34 修改
阅读量295 收藏 7
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 开发语言
于 2024-09-28 11:13:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lumos_yyyx/article/details/142528972
版权

1、栈

1.1 栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

 1.2 栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

1.2.1 Stack.h

#pragma once
#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);
//销毁
void STDestroy(ST* pst);
//入栈
void STPush(ST* pst, STDataType x);
//出栈
void STPop(ST* pst);
//获取栈顶元素
STDataType STTop(ST* pst);
//判断是否为空
bool STEmpty(ST* pst);
//获取栈中有效元素的个数
int STSize(ST* pst);

1.2.2 Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"

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 = 0;
	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, newcapacity * sizeof(STDataType));
		if (NULL == tmp)
		{
			perror("realloc");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}

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

void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	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;
}

1.2.3 test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"

void TestStack1()
{
	ST st;
	STInit(&st);
	STPush(&st, 1);
	STPush(&st, 2);
	STPush(&st, 3);
	printf("%d\n", STTop(&st));
	STPop(&st);

	STPush(&st, 4);
	STPush(&st, 5);
	while (!STEmpty(&st))
	{
		printf("%d ", STTop(&st));
		STPop(&st);
	}
	STDestroy(&st);
}

int main()
{
	TestStack1();
	return 0;
}

2、队列

2.1 队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 的性质。

进行插入操作的一端称为队尾，进行删除操作的一端称为队头。

2.2 队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

2.2.1 Queue.h

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

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

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

//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);
//队尾入队列
void QueuePush(Queue* pq, QDataType x);
//队头出队列
void QueuePop(Queue* pq);
//获取队头元素
QDataType QueueFront(Queue* pq);
//获取队尾元素
QDataType QueueBack(Queue* pq);
//获取队列中有效元素个数
int QueueSize(Queue* pq);
//检测队列是否为空
bool QueueEmpty(Queue* pq);

2.2.2 Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"

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

	pq->phead = NULL;
	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 (NULL == newnode)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

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

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->phead->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->ptail->data;
}

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

	return pq->size;
}

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

	return pq->size == 0;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"

void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 4);
	QueuePush(&q, 3);
	QueuePush(&q, 2);
	QueuePush(&q, 1);

	QueuePop(&q);
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	QueueDestroy(&q);
}

int main()
{
	TestQueue();
	return 0;
}

3、栈和队列练习题

3.1 括号匹配问题

20. 有效的括号 - 力扣（LeetCode）

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;
            }
            else
            {
                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;
}

3.2 用队列实现栈

225. 用队列实现栈 - 力扣（LeetCode）

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

MyStack* myStackCreate() 
{
	MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
	obj->q1 = (Queue*)malloc(sizeof(Queue));
	obj->q2 = (Queue*)malloc(sizeof(Queue));

	QueueInit(obj->q1);
	QueueInit(obj->q2);
	return obj;
}

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

int myStackPop(MyStack* obj) {
	Queue* pEmpty = obj->q1;
	Queue* pNonEmpty = obj->q2;
	if (!QueueEmpty(obj->q1))
	{
		pEmpty = obj->q2;
		pNonEmpty = obj->q1;
	}

	while (QueueSize(pNonEmpty) > 1)
	{
		QueuePush(pEmpty, QueueFront(pNonEmpty));
		QueuePop(pNonEmpty);
	}
	int top = QueueFront(pNonEmpty);
	QueuePop(pNonEmpty);

	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.3 用栈实现队列

232. 用栈实现队列 - 力扣（LeetCode）

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

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

	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);
}

3.4 设计循环队列

622. 设计循环队列 - 力扣（LeetCode）

 

typedef struct 
{
	int front;
	int rear;
	int k;//队列长度，假设为5
	int* a;//数组指针
} MyCircularQueue;

//这个函数动态开辟的obj或者数组都是为下面做铺垫的
MyCircularQueue* myCircularQueueCreate(int k) 
{
	MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	obj->a = (int*)malloc(sizeof(int) * (k + 1));
	obj->front = obj->rear = 0;
	obj->k = k;

	return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
	return obj->front == obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
	//(5+1)%(5+1)==0的时候是满的
	return (obj->rear + 1) % (obj->k + 1) == obj->front;
}

//向循环队列插入一个元素，如果成功插入则返回真
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
	//如果不是满队列才可以插入
	if (myCircularQueueIsFull(obj))
		return false;

	obj->a[obj->rear] = value;
	obj->rear = (obj->rear + 1) % (obj->k + 1);
	return true;
}

//从循环队列中删除一个元素，如果成功删除则返回真
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
	if (myCircularQueueIsEmpty(obj))
		return false;

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

int myCircularQueueFront(MyCircularQueue* obj) 
{
	if (myCircularQueueIsEmpty(obj))
		return -1;

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

int myCircularQueueRear(MyCircularQueue* obj) 
{
	if (myCircularQueueIsEmpty(obj))
		return -1;

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

void myCircularQueueFree(MyCircularQueue* obj) 
{
	free(obj->a);
	free(obj);
}

3.5 选择题

现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N。其队内有效长度为？(假设队头不存放数据)

A (rear - front + N) % N + 1

B (rear - front + N) % N

C (rear - front) % (N + 1)

D (rear - front + N) % (N - 1)

答案是B，代入计算一下就可以

小叶学C++
关注
专栏目录
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2253
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
Java模拟栈和队列数据结构的基本示例讲解
09-02
Java中的栈和队列是两种基本的数据结构，它们在编程中有着广泛的应用。栈（Stack）遵循“后进先出”（Last In First Out, LIFO）原则，而队列（Queue）则遵循“先进先出”（First In First Out, FIFO）原则。 栈的...
【数据结构】栈和队列的模拟实现（两个方式实现）
加油，考上985的研究生
11-13 1591
这一篇博客将学习栈和队列的相关知识，栈和队列是两种基础的数据结构，在现在一定要打好基础，在之后的学习生涯中，也常常遇见，例如：深度优先搜索（DFS）广度优先搜索（BFS）……今天要学习栈和队列的模拟实现：用数组模拟实现栈，用单链表模拟实现队列，用数组模拟实现队列。
【数据结构】栈和队列的实现及应用
学了就忘是正常现象
08-18 3622
栈和队列
数据结构——Java实现栈和队列
2301_77116754的博客
01-19 854
Java实现栈，Java实现队列，以数组为底层来实现栈和队列，232.用栈实现队列，225.用队列实现栈
【数据结构题目】循环队列，以及队列实现栈的模拟
GGBond778的博客
08-11 866
本期将讲述力扣上的经典题型，循环队列以及队列转化为栈的模拟，分别从内部原理，以及实现过程讲解，以及相关代码的片段。
C语言之数据结构之栈和队列的运用
2301_81988400的博客
05-04 2419
C语言数据结构——用两个队列实现栈和用两个栈实现队列的思路讲解和代码实现
【数据结构】—手把手带你用C语言实现栈和队列（超详细！）
B1ue还在专注
08-07 1903
本文为作者对于栈和队列的学习总结，在写本文的过程中，作者重新捋了一遍一遍这两个数据结构，相信按照循序渐进的思路对于读者会有所帮助♪(･ω･)ﾉ
C++数据结构：栈和队列的应用
攻城狮的博客
05-29 2045
C++ 是一种面向对象的编程语言，它提供了多种数据结构，前面文章已介绍过数组、链表、hash表，并用自己的方法实现。用于存储和操作数据的结构在STL中还有很多，其中两种常用的数据结构是栈和队列。本文将介绍栈和队列的概念，特点，实现方式和应用场景。
Java数据结构--栈和队列
xd__xy的博客
12-07 1178
如图所示，「双向队列 double-ended queue」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。然而，数组和链表都可以在任意位置添加和删除元素，因此栈可以视为一种受限制的数组或链表。将把元素添加到栈顶的操作叫作“入栈”，删除栈顶元素的操作叫作“出栈”。如图所示，我们将队列头部称为“队首”，尾部称为“队尾”，将把元素加入队尾的操作称为“入队”，删除队首元素的操作称为“出队”。我们可以将链表的“头节点”和“尾节点”分别视为“队首”和“队尾”，规定队尾仅可添加节点，队首仅可删除节点。
C++ stack&&queue 栈和队列的使用&&模拟实现
weixin_57761086的博客
10-03 2304
讲解C++的栈和队列的使用与模拟实现。模拟实现中，用文字叙述来帮助读者更好地理解堆和栈的模拟实现。
Java模拟栈和队列数据结构的基本示例讲解共4页.pdf
10-30
本篇文档《Java模拟栈和队列数据结构的基本示例讲解共4页.pdf》将深入浅出地介绍如何在Java中实现栈和队列，以帮助开发者更好地理解和应用这些概念。 首先，让我们来了解栈和队列的基本特性： 1. **栈（Stack）**...
Python 实现数据结构中的的栈队列
09-19
栈和队列是两种基本且常用的数据结构，它们在Python中有着多种实现方式。本篇文章将详细探讨如何使用Python来实现这些数据结构。 首先，栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构，它遵循...
C++实现的任意进制转换（数据结构——栈和队列）
08-10
本文将深入探讨如何使用C++语言实现任意进制转换，特别是涉及到小数部分的处理，并结合数据结构中的栈和队列进行阐述。C++作为一门强大的静态类型语言，其丰富的库支持和高效性能使得它成为实现这种算法的理想选择。...
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 610
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
[数据结构] 二叉树题目(一)
nmbg11的博客
09-27 466
leetcode有关二叉树的相关题目. 翻转二叉树. 相同的树. 对称二叉树.
数据结构（Map、Set、搜索树）
wuweixiaoyue的博客
09-27 803
概念优势：查找元素时可以直接砍去一半的值，达到 log(N)示例：此时如果要找4，因为4比6小，所以要去6的左边找，此时因为4比3大，所以要去3的右树找，最终找到了如果找到了就返回，如果直到全部找完遇到null了也没找到，说明该搜索树下根本就没有该元素有序问题：二叉搜索树的中序遍历是有序的概念：Map和Set是专门用来进行搜索的容器或数据结构Set是纯key模型，Map是 Key-Value 模型Set最大的功能就是对集合中的元素进行去重接口实例化。
数据结构和算法基础（一）
最新发布
叶子叶来
09-30 453
趁空闲时间刷一遍极客时间上王争的《数据结构与算法之美》课程，个人觉得写的很好，每章节由浅入深且从基础到引入设计类问题，如果写过很多代码想要进行架构设计转型时再回头看这些基础知识还蛮有趣的，以下纪录下随着课程走的部分实现代码和思考； 内容主要是笔记和代码，注：手写一遍代码是有必要的；
python-ds：Python 中的数据结构库（适用于面试的数据结构和算法合集）
技术无疆
09-27 1913
python-ds 是一个开源的 Python 数据结构库，旨在提供多种高级数据结构的实现，如链表、树、图等。这些数据结构可用于解决各种计算问题，增强 Python 在数据处理和算法开发方面的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值