005+limou+C语言栈与队列的实现

limou3434

已于 2023-05-17 21:12:40 修改

阅读量463

点赞数 3

分类专栏：数据结构和算法（第一版）文章标签： c语言数据结构队列栈

于 2023-04-27 18:24:53 首次发布

本文链接：https://blog.csdn.net/m0_73168361/article/details/130412540

版权

数据结构和算法（第一版）专栏收录该内容

8 篇文章 0 订阅

订阅专栏

0.前言

您好，这里是limou3434的一篇个人博文，感兴趣的话您也可以看看我的其他文章。
本次我给您带来的内容是栈和队列在C语言中的实现。在本次内容中，如果您对我之前写的“有关C语言内的顺序表和链表实现”比较清楚的话，那么本次分享的知识对您来说易如反掌（因为实际上，本文实现的栈和队列不过是顺序表和链表的特殊情况罢了）

1.栈基础

1.1.栈的基本概念

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。
- 栈的插入元素操作叫“入栈（或者压栈、进栈）”
- 栈的移除元素操作叫“出栈”，出栈必须从最靠近栈出口的一端出元素
进行进栈出栈操作的一端称为栈顶，另一端称为栈底。栈中的每一个数据元素都遵守“LIFO（Last In First Out“后进先出”）”原则。
栈的实现可以用顺序表和链表，分别叫作“顺序栈和”和“链式栈”。其中顺序表实现的栈比较常见（链式栈的实现需要注意把单链表的首节点作为栈顶，尾节点作为栈底。对于链式栈，入栈相当于给单链表头插，出栈就相当于给单链表头删）
DFS是深度优先遍历（会用到递归/栈）

1.2.栈的基本接口

1.2.1.对于栈来说，栈主要有以下的接口

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
//> 栈的实现
//> 1.支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
    STDataType* _a;
    int _top;       // 栈顶
    int _capacity;  // 容量 
}Stack;
//> 2.初始化栈 
void StackInit(Stack* ps);
//> 3.入栈 
void StackPush(Stack* ps, STDataType data);
//> 4.出栈 
void StackPop(Stack* ps);
//> 5.获取栈顶元素 
STDataType StackTop(Stack* ps);
//> 6.获取栈中有效元素个数 
int StackSize(Stack* ps);
//> 7.检测栈是否为空，如果为空返回非零，如果不为空返回0 
int StackEmpty(Stack* ps);
//> 8.销毁栈 
void StackDestroy(Stack* ps);

1.2.2.栈接口的具体实现

//> 2.初始化栈 
void StackInit(Stack* ps)
{
    //1.检查指针有效性
    assert(ps);

    //2.初始化栈的信息
    ps->_a = (STDataType*)malloc(sizeof(STDataType) * 4);//先给上4个空间，并且检查是否申请成功
    if (!ps->_a)
    {
        perror("malloc fail!\n");
        return;
    }
    ps->_top = 0;//这个赋值也可以是-1
    ps->_capacity = 4;
}
//> 3.入栈 
void StackPush(Stack* ps, STDataType data)
{
    //1.检查指针有效性
    assert(ps);
    //2.检查栈容量是否满了
    if (ps->_capacity == ps->_top)
    {
        STDataType* cache = (STDataType*)realloc(ps->_a, sizeof(STDataType) * ((ps->_capacity) * 2));
        if (!cache)
        {
            printf("realloc fail!\n");
            exit(-1);
        }
        ps->_a = cache;
        ps->_capacity = ps->_capacity * 2;
    }
    //3.入栈并且更新栈的数据
    ps->_a[ps->_top] = data;
    ps->_top++;
}
//> 4.出栈 
void StackPop(Stack* ps)
{
    //1.检查指针有效性
    assert(ps);
    //2.检查栈是否有元素
    assert(ps->_top > 0);
    //3.直接利用下标“删除”元素，注意栈内存储元素的“实际下标”比“_top”的数值小1
    ps->_top--;
}
//> 5.获取栈顶元素 
STDataType StackTop(Stack* ps)
{
    //1.检查指针的有效性
    assert(ps);
    //2.检查栈是否还有元素
    assert(ps->_top > 0);
    //3.取出栈顶元素
    return ps->_a[ps->_top - 1];
}
//> 6.获取栈中有效元素个数 
int StackSize(Stack* ps)
{
    //1.检查指针的有效性
    assert(ps);
    //2.获取元素个数
    return ps->_top;
}
//> 7.检测栈是否为空，如果为空返回非零，如果不为空返回0 
int StackEmpty(Stack* ps)
{
    assert(ps);
    return (ps->_top == 0);
}
//> 8.销毁栈 
void StackDestroy(Stack* ps)
{
    assert(ps);
    free(ps->_a);
    ps->_a = NULL;
    ps->_capacity = ps->_top = 0;
}

1.3.栈的测试用例

void test_1()
{
    Stack st1;//创建一个栈结构体
    StackInit(&st1);//初始化这个栈
    StackPush(&st1, 1);//压栈
    StackPush(&st1, 2);//压栈
    StackPush(&st1, 3);//压栈
    StackPush(&st1, 4);//压栈
    StackPush(&st1, 5);//压栈

    printf("<栈顶>\n");
    while (!StackEmpty(&st1))//只要栈不为空就进入循环
    {
        printf("%3d\n", StackTop(&st1));//取出栈顶元素并且打印
        StackPop(&st1);//删除栈顶元素
    }
    printf("<栈底>\n");
    //StackPop(&st1);//非法删除
    //StackPop(&st1);//非法取栈顶元素
    StackDestroy(&st1);//销毁栈结构体
}

2.队列基础

2.1.队列的基本概念

队列是一种特殊的线性表，其只允许在一端进行插入元素操作，而另一端进行删除元素操作。
- 队列的插入元素操作叫“入队尾”
- 队列的移除元素操作叫“出队头”
进行出队的一端称为队头，进行入队称为队尾。队列中的每一个数据元素都遵守“FIFO（First In First Out“先近后出”）”原则。
队列的实现可以用顺序表和链表，其中链表实现的队列比较常见
队列最经典的应用是抽号机，对于特定序列的数据入队，其出队列也必然是按照原顺序的
BFS是广度优先遍历（会用到队列）

2.2.队列的基本接口

2.2.1.对于队列来说，队列主要有以下得接口

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
//> 队列的实现
//> 1.链式结构：表示队列的一个元素
typedef int QDataType;
typedef struct QListNode
{
    struct QListNode* _pNext;
    QDataType _data;
}QNode;
//> 2.队列的结构 
typedef struct Queue
{
    QNode* _front;  //队头
    QNode* _rear;   //队尾
}Queue;
//> 3.初始化队列 
void QueueInit(Queue* q);
//> 4.队尾入队列 
void QueuePush(Queue* q, QDataType data);
//> 5.队头出队列 
void QueuePop(Queue* q);
//> 6.获取队列头部元素 
QDataType QueueFront(Queue* q);
//> 7.获取队列队尾元素 
QDataType QueueBack(Queue* q);
//> 8.获取队列中有效元素个数 
int QueueSize(Queue* q);
//> 9.检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
//> 10.销毁队列 
void QueueDestroy(Queue* q);

2.2.2.队列接口的具体实现

//> 3.初始化队列 
void QueueInit(Queue* q)
{
	//1.检查指针的有效性
	assert(q);
	//2.初始化队列（队尾队头都置为空）
	q->_front = q->_rear = NULL;
}
//> 4.队尾入队列（链表尾插）
void QueuePush(Queue* q, QDataType data)
{
	//1.检查指针的有效性
	assert(q);
	//2.先申请一个链表节点并且存储好数据
	QNode* cache = (QNode*)malloc(sizeof(QNode));
	if (!cache)
	{
		perror("malloc fail\n");
		exit(-1);
	}
	cache->_data = data;
	cache->_pNext = NULL;
	//3.开始尾插
	if (q->_rear == NULL)//如果队列为空
	{
		q->_front = q->_rear = cache;
	}
	else
	{
		q->_rear->_pNext = cache;
		q->_rear = cache;//改变队列的队尾标记，形成新的队尾
	}
}
//> 5.队头出队列（链表头删）
void QueuePop(Queue* q)
{
	//1.检查指针有效性
	assert(q);
	assert(q->_front);
	//2.开始出数据
	//2.1.处理特殊情况（只剩一个节点）
	if (q->_front == q->_rear)
	{
		free(q->_front);
		q->_front = q->_rear = NULL;
		return;
	}
	//2.2.处理一般情况
	QNode* delNode = q->_front;
	q->_front = q->_front->_pNext;
	free(delNode);
}
//> 6.获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	//1.检查指针的有效性
	assert(q);
	assert(q->_front);
	//2.返回队头的值
	return q->_front->_data;
}
//> 7.获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	;
}
//> 8.获取队列中有效元素个数（这里也可以让队列结构体多加一个size成员） 
int QueueSize(Queue* q)
{
	//1.检查指针的有效性
	assert(q);
	//2.循环计数，返回有效元素个数
	int size = 0;
	QNode* cur = q->_front;
	while (cur)
	{
		size++;
		cur = cur->_pNext;
	}
	return size;
}
//> 9.检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	//1.检查指针的有效性
	assert(q);
	//2.检测队列是否为空
	return q->_front == NULL;
}
//> 10.销毁队列 
void QueueDestroy(Queue* q)
{
	//1.检查指针的有效性
	assert(q);
	//2.开始销毁
	QNode* cur = q->_front;
	while (cur)
	{
		QNode* next = cur->_pNext;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;
}

2.3.队列的测试用例

void test_2()
{
    Queue q;
    QueueInit(&q);//初始化队列
    QueuePush(&q, 5);//入队尾
    QueuePush(&q, 4);//入队尾
    QueuePush(&q, 3);//入队尾
    QueuePush(&q, 2);//入队尾
    QueuePush(&q, 1);//入队尾
    printf("队头->");
    while (!QueueEmpty(&q))//若为非空队列则进入循环
    {
        printf("%d->", QueueFront(&q));//取出队头，并且打印
        QueuePop(&q);
    }
    printf("队尾");
    //QueueFront(&q);//非法取出队头
    //QueuePop(&q);//非法删除队头
    QueueDestroy(&q);
}

3.栈与队列oj题目

这里有几道题目可供你一做，我也提供了一些比较经典的解法，你也可以看看其他解友的代码，他们的写得要比我更加高效可用得多

3.1.有效的括号力扣

3.2.栈模拟队列力扣

3.3.队列模拟栈力扣

4.总结

总结一下，本次我给您带来了
- 1.有关栈的基础概念以及具体实现
- 2.有关队列的基础概念以及具体实现
也许看到这里您也许就会明白为什么我开头会说“本文实现的栈和队列不过是顺序表和链表的特殊情况罢了”这句话的原因了，您只需要记住Last In First Ou和First In First Out这两个原则，那么实现栈和队列并不难，这两者在日后的学习中是非常有用的。具体情况还请等待我后续的内容，当然您也可以去Google一下，相信您一定能获得比我这里更多的内容。
最后，愿与君共勉。