栈和队列详解

已于 2023-08-12 19:01:59 修改
阅读量565 收藏 10
点赞数 15
分类专栏： 数据结构 文章标签： 数据结构
于 2023-08-12 18:58:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74190188/article/details/132237531
版权

目录

栈

栈的概念及结构：

 栈的实现：

 代码实现：

Stack.h

stack.c

 队列：

概念及结构：

 队列的实现：

 代码实现：

Queue.h

Queue.c

 拓展：

循环队列（LeetCode题目链接）：

  • 栈

栈的概念及结构：

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。

       进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。

       栈中的数据元素遵守“先进后出/后进先出”的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。

 “先进后出/后进先出”示意图：

 栈的实现：

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

 代码实现：
Stack.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

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);
//取栈顶元素
STDataType STTop(ST* ps);
//数据个数
int STSize(ST* ps);
//判空
bool STEmpty(ST* ps);
stack.c
#include"Stack.h"
//初始化
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];
}
//数据个数
int STSize(ST* ps)
{
	assert(ps);
	assert(ps->a);
	return ps->top;
}
//判空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

测试代码：

#include"Stack.h"
int main()
{
    ST p1;
	STInit(&p1);
	int i = 0;
	//入栈
	for (i = 1; i <= 10; i++)
	{
		STPush(&p1, i);
	}

	printf("栈中数据数量：%d\n", STSize(&p1));
	//出栈
	for (i = 0; i < 5; i++)
	{
		STDataType a = STTop(&p1);
		printf("%d ", a);
		STPop(&p1);
	}
	printf("\n");
	printf("栈顶元素：%d\n", STTop(&p1));
	printf("栈中数据数量：%d\n", STSize(&p1));

	STDestroy(&p1);
    return 0;
}

运行结果：

 队列：

概念及结构：

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有“先             进先出/后进后出”的特点。

入队列：进行插入操作的一端称为队尾。

出队列：进行删除操作的一端称为队头。

​​​​​​​“先进先出/后进后出”示意图： 

 队列的实现：

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

 代码实现：
Queue.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

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

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;
//初始化
void QueueInit(Que* pq);
//销毁
void QueueDestroy(Que* pq);
//入队
void QueuePush(Que* pq, QDataType x);
//出队
void QueuePop(Que* pq);
//取队头
QDataType QueueFront(Que* pq);
//取队尾
QDataType QueueBack(Que* pq);
//判空
bool QueueEmpty(Que* pq);
//有效数据
int QueueSize(Que* pq);
Queue.c
#include"Queue.h"

//初始化
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;
}
//判空 ：空返回1，非空返回0
bool QueueEmpty(Que* pq)
{
	assert(pq);
	return pq->head == NULL;
}
//有效数据
int QueueSize(Que* pq)
{
	assert(pq);
	return pq->size;
}

代码测试：

#include"Queue.h"
int main()
{
	Que p2;
	QueueInit(&p2);
	int i = 0;
	//入队
	for (i = 11; i <= 20; i++)
	{
		QueuePush(&p2, i);
	}

	printf("队列中数据数量：%d\n", QueueSize(&p2));
	//出队
	for (i = 0; i < 7; i++)
	{
		QDataType a = QueueFront(&p2);
		printf("%d ", a);
		QueuePop(&p2);
	}
	printf("\n");
	printf("队头元素：%d 队尾元素：%d\n", QueueFront(&p2), QueueBack(&p2));
	printf("队列中数据数量：%d\n", QueueSize(&p2));
	
	QueueDestroy(&p2);
	return 0;
}

运行实例：

 拓展：

循环队列（LeetCode题目链接）：

循环队列是一种线性数据结构，其操作表现基于普通队列“先进先出”原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

循环队列可以使用数组实现，也可以使用循环链表实现。

以循环链表实现为例：

 若仅仅是需要几个空间就创建几个空间，则空和满两种情况将无法区分，因此我们可以比实际需要多创建一个空间，这一个多创建出来空间不存储数据，则有如下情况：

 则满和空两种情况就可以区分出来了：front=rear-->空

                                                              rear的下一个=front-->满

同时为了方便取队尾数据，可以定义一个全局变量指向队尾位置（即rear指向位置的前一个）。

具体代码实现：

typedef struct List
{
    int val;
    struct List*next;
}list;
typedef struct 
{
    list*front;
    list*rear;
} MyCircularQueue;
list*tail;//定义一个全局变量记录rear的前一个
MyCircularQueue* myCircularQueueCreate(int k)
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (obj == NULL)
    {
        perror("malloc failed");
        exit(-1);
    }
    obj->front = NULL;
    obj->rear = NULL;
    int n = k + 1;
    while (n--)
    {
        list* new = (list*)malloc(sizeof(list));
        if (new == NULL)
        {
            perror("malloc failed");
            exit(-1);
        }
        new->val = 0;
        new->next = obj->front;
        if (obj->front == NULL)
        {
            obj->front = new;
            obj->rear = new;
        }
        else
        {
            obj->rear->next = new;
            tail=new;
            obj->rear = obj->rear->next;
        }
    }  
    obj->rear=obj->front;
    return obj;
}
//判空：空返回真，非空返回假
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->front==obj->rear;
}
//是否已满:已满返回真，不满返回假
bool myCircularQueueIsFull(MyCircularQueue* obj)
{
    return obj->rear->next==obj->front;
}
//插入数据：插入成功返回真，失败返回假
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    assert(obj);
    if(myCircularQueueIsFull(obj))//已满
    {
        return false;
    }
    else
    {
        obj->rear->val=value;
        obj->rear=obj->rear->next;
        tail=tail->next;
        return true;
    }
}
//从队列中删除元素
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front=obj->front->next;
        return true;
    }
}
//获取对首元素
int myCircularQueueFront(MyCircularQueue* obj) 
{
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->front->val;
}
//获取队尾元素
int myCircularQueueRear(MyCircularQueue* obj) 
{
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    /*list*cur=obj->front;
    while(cur->next!=obj->rear)
    {
        cur=cur->next;
    }
    return cur->val;*/
    return tail->val;
}
//释放空间
void myCircularQueueFree(MyCircularQueue* obj) 
{
    while(obj->front!=obj->rear)
    {
        list*Next=obj->front->next;
        free(obj->front);
        obj->front=Next;
    }
    free(obj->rear);

    free(obj);
}

 利用数组也可以实现，与链表类似在创建空间是同样需要多创建一个，但是因为队头、队尾没有链接关系，所以利用数组实现时与利用循环链表实现会有所不同：

 与循环链表类似，用数组实现循环队列时，当rear=front时，队列为空；在判断队列是否满时，虽然也是用rear的下一个等于front（即rear+1==front），但是不能单单使用 rear+1==front 判断，因为数组实现时，队首和队尾没有链接关系，当rear在数组最后一个位置时，循环队列已满，但rear+1会越界往后访问，且当front在数组最后一个位置时，删除数据后执行front+1也会出现越界访问的问题，出现错误，因此应想办法让rear和front都在数组范围内变化。

观察数组下标，可以让rear+1和front+1都模上k+1，问题就能很好解决。

具体代码实现：

typedef struct
{
    int k;
    int front;
    int rear;
    int* queue;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k)
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (obj == NULL)
    {
        perror("malloc failed");
        exit(-1);
    }
    obj->k = k;
    obj->front = 0;
    obj->rear = 0;
    obj->queue = (int*)malloc(sizeof(int) * (k + 1));
    if (obj->queue == NULL)
    {
        perror("malloc failed");
        exit(-1);
    }
    return obj;
}
//判空：空返回真，非空返回假
bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
    return obj->rear == obj->front;
}
//是否已满:已满返回真，不满返回假
bool myCircularQueueIsFull(MyCircularQueue* obj)
{
    return (obj->rear + 1) % (obj->k + 1) == obj->front;
}
//插入数据：插入成功返回真，失败返回假
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
    assert(obj);
    if (myCircularQueueIsFull(obj))//已满
    {
        return false;
    }
    else
    {
        obj->queue[obj->rear] = value;
        obj->rear = (obj->rear + 1) % (obj->k + 1);
        return true;
    }
}
//从队列中删除元素
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
    assert(obj);
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front = (obj->front + 1) % (obj->k + 1);
        return true;
    }
}
//获取对首元素
int myCircularQueueFront(MyCircularQueue* obj)
{
    assert(obj);
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->queue[obj->front];
}
//获取队尾元素
int myCircularQueueRear(MyCircularQueue* obj)
{
    assert(obj);
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->queue[(obj->rear + obj->k) % (obj->k + 1)];
}
//释放空间
void myCircularQueueFree(MyCircularQueue* obj)
{
    free(obj->queue);
    obj->queue = NULL;
    free(obj);
}

wlaa
关注
专栏目录
C语言 表、栈和队列详解及实例代码
01-20
C语言 表、栈和队列详解 表ADT  形如A1,A2,A3…An的表，这个表的大小为n，而大小为0的表称为空表，非空表中，Ai+1后继Ai，Ai-1前驱Ai，表ADT的相关操有PrintList打印表中的元素；CreateEmpty创建一个空表；Find...
Java之栈和队列详解
qq_73471456的博客
01-23 1736
Java知识来实现数据结构之栈和队列，带你深入了解栈和队列的原理实现
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 25万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
《数据结构C语言版》——栈和队列详解(图文并茂)，从零开始的学习
青春无问西东 岁月自成芳华
04-20 4773
一文搞懂数据结构系列之栈和队列部分，从0基础到快速手敲数据结构，小白也能轻松看懂的宝典！
数据结构栈和队列详解.zip
04-03
栈和队列是两种非常基础且重要的数据结构，它们在计算机科学和软件开发中都有着广泛的应用。下面我将详细解释这两种数据结构。 栈（Stack） 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。这...
栈和队列详解：数据结构中的栈操作与队列概念
"本文主要介绍了数据结构中的栈和队列，特别是双端队列的概念，以及栈在C语言中的描述。栈是一种特殊的数据结构，仅允许在表尾进行插入和删除操作，即栈顶，而队列则允许在一端插入（队尾）并在另一端删除（队头）。...
数据结构与算法：高级数据结构与实际应用
weidl001的博客
10-16 1118
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
【数据结构】AVL树（C++实现）
weixin_73914025的博客
10-13 763
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。它的左右子树都是AVL树左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在Olog2nO(log_2 n)Olog。
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 607
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构——栈
2301_76227083的博客
10-14 724
简单介绍了栈是什么，以及如何用C语言实现一个栈
七大经典排序算法优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序、归并排序代码详解
weixin_64593595的博客
10-15 1738
本文深入探讨了七大经典排序算法的优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序和归并排序。适合需要稳定性排序的场景，通过对这些算法的分析和优化，能够根据具体需求选择合适的排序方法，从而提高程序性能和效率。
手撕数据结构 —— 堆（C语言讲解）
最新发布
知其然 知其所以然
10-17 834
想要弄清楚什么是堆，首先需要了解二叉树的相关知识，推荐阅读数据结构——树和二叉树简介。大根堆：如果一棵完全二叉树中除了叶子结点的每个结点的值都大于其左右孩子，则这棵完全二叉树就叫做大根堆。大根堆的对顶元素是这棵树中的最大元素。小根堆：如果一棵完全二叉树中除了叶子结点的每个结点的值都小于其左右孩子，则这棵完全二叉树就叫做小根堆。小根堆的堆顶元素是整棵树的最小元素。a指向底层的数组空间。size记录有效数据的个数。capacity记录空间的大小，当空间不够时自动扩容。
浙大数据结构：KMP 字符串匹配算法比较
qq_74924951的博客
10-16 307
Kmp算法学习
c++初阶数据结构速成
2302_80418176的博客
10-17 1034
STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的 组件库，而且是一个包罗数据结构与算法的软件框架总结：一个可复用，同时又包含了数据结构和算法的软件框架。那么这里需要知道的是priority_queue是一个容器，并且是优先队列。函数声明 接口说明。
数据结构（二）顺序表应用：通讯录
cloud_disspated的博客
10-13 294
/定义联系人数据// 姓名 性别 年龄 电话 地址int age;}peoInfo;
数据结构之队列（python）
huaz_md的博客
10-13 897
队列的两端都"开口"，要求数据只能从一端进，从另一端出，如图 1 所示：进数据的一端为 “队尾”，出数据的一端为 “队头”，数据元素进队列的过程称为 “入队”，出队列的过程称为 “出队队列中数据的进出要遵循 “先进先出” 的原则，即最先进队列的数据元素，同样要最先出队列。拿图1中的队列来说，从数据在队列中的存储状态可以分析出元素1最先进队，其次是元素2最后是元素3。此时如果将元素3出队，根据队列 “先进先出” 的特点，元素1要先出队列元素2再出队列，最后才轮到元素3出队列。因此，数据从表的。
数据结构之链表
2301_79562326的博客
10-13 837
使用“快慢指针”方法，快指针一次走两步，慢指针一次走一步。如果链表有环，快慢指针会在某一点相遇。：要求将单向链表反转，使得原来的头节点变为尾节点，尾节点变为头节点。遍历链表就是从头节点开始，依次访问每个节点，直到。（对于单向链表）或循环到头节点（对于循环链表）。：将两个已经排序的链表合并为一个新的有序链表。// 删除头节点示例。
栈和队列详解：取链队列首元素
"该资源主要介绍了数据结构中的栈和队列，特别是如何取链队列的第一个元素，并提供了栈的相关概念、实现方式以及操作示例。" 在数据结构中，栈和队列是两种非常基础且重要的线性数据结构。栈（Stack）遵循“后进先...
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值