C语言数据结构—栈和队列实现

最新推荐文章于 2024-08-29 21:14:24 发布
最新推荐文章于 2024-08-29 21:14:24 发布
阅读量1.2k 收藏 23
点赞数 46
文章标签： dreamweaver
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1007551460/article/details/139997461
版权

目录

前言

一、栈

1.栈的概念及结构简析

2.栈的实现方式

3.栈的基本功能实现

（1）栈的成员

（2）栈的初始化

（3）入栈出栈操作

（4）获取栈顶元素

（5）获取栈中有效元素个数

（6）检测栈是否为空

（7）销毁栈

二、队列

1.队列的概念及结构简析

2.队列的实现方式

3.队列的基本功能实现

（1）队列的结构体

（2）队列的初始化

（3）入队列出队列操作

（4）获取队头元素

（5）获取队尾元素

（6）获取队列中有效元素个数

（7）检测队列是否为空

（8）销毁队列

三、栈和队列的完整代码参考

1.栈

2.队列

前言

    栈和队列是C语言中的两种容器，学习C语言的栈和队列有助于我们更好地理解栈和队列的底层实现。

一、栈

1.栈的概念及结构简析

  栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。
进行数据插入和删除操作的一端，称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出原则。
栈有两大操作方式：
    一是压栈，也叫入栈/进栈，是将元素插入栈顶的操作。
    二是出栈，是将元素从栈中删除的操作。
    图示：
请添加图片描述

请添加图片描述

2.栈的实现方式

栈有两大实现方式，分别是顺序栈和链式栈
顺序栈：用数组来作为栈的结构存储元素
链式栈：用链表来作为栈的结构存储元素
    单链出栈入栈要先找到尾节点，效率低，而双向链表和带头作栈顶的链表都需要额外的空间存储地址。
    顺序栈只需要记录栈顶位置，同时可通过栈顶位置知道有效元素个数，进行出入栈操作比较便捷，因为对于栈来说出入栈类似尾插尾删，而对于数组来说尾插尾删效率很高。
    综上所述，实现栈使用数组来实现更优一些，因为在数组尾插的代价较小，且不需要额外的空间存储地址。

本文采用数组来实现栈。

3.栈的基本功能实现

（1）栈的成员

栈顶：记录栈顶元素的位置，方便进行尾插尾删，这里的top表示的是栈顶元素的后一位，这样top就可以表示有效元素的数量。
容量：存储有效元素的最大数量。

//重定义，方便后续更改存储数据的类型
typedef int STDataType;
typedef struct Stack {
	//用数组来存储
	STDataType* a;
	//栈顶元素的后一位
	int top;
	//容量
	int capacity;
}ST;

​

（2）栈的初始化

​void STInit(ST* ps)
{
	//提前断言，阻止人为(我们)传空指针
	assert(ps);
	//数组初始化是置空，top、容量初始化置零
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

​

（3）入栈出栈操作

  入栈：
入栈注意事项：
1、入栈前先判断是否要扩容，扩容看有效数据个数是否达到了栈的容量，达到了就扩容，没有就不用扩容直接进行入栈操作；
2、传入的数据入栈，要将其存入栈中
3、入栈后有效元素增加，有元素的数量就增加，这里有个小技巧，有效元素数量刚好等于top的值，所以我们改变top就可以了，如果有扩容，容量的值也要对应有更新。

请添加图片描述

void STPush(ST* ps, STDataType x)
{
	//提前断言，阻止人为(我们)传空指针
	assert(ps);
	//入栈前，先判断是否需要扩容
	if(ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//扩容
		STDataType* tmpa = (STDataType*)realloc(ps->a, sizeof(STDataType)*newcapacity);
		//扩容失败，抛出警告（几乎不会出现扩容失败现象）
		if (!tmpa)
		{
			perror("realloc fail");
			exit(-1);
		}
		//将原来小数组换成了一个更大的数组
		ps->a = tmpa;
		//容量相应地更新
		ps->capacity = newcapacity;
	}
	//传入数据读入到栈里
	ps->a[ps->top] = x;
	//top值更新，也是有效元素数量更新
	ps->top++;
}

​

   出栈：
出栈注意事项：
1、注意到栈顶其实是一个数组的尾，将top减一，原栈顶的数就失联了，这个数也就被删掉了。
2、出栈前要判断栈是否为空，否则栈空继续减一，top就为-1了，这样造成了越界访问。

void STPop(ST* ps)
{
	//提前断言，阻止人为(我们)传空指针
	assert(ps);
	//提前断言，阻止空栈时再减一
	assert(ps->top > 0);
	--ps->top;
}

​

（4）获取栈顶元素

注意事项：
1、top是有效元素个数将其减一就得到栈顶的下标，用下标访问法即可获取栈顶元素。
2、获取前要判断栈是否为空。

​
STDataType STTop(ST* ps)
{
	assert(ps);
	//提前断言，组织栈空时访问
	assert(ps->top > 0);
	//返回栈顶元素
	return ps->a[ps->top - 1];
}

​

（5）获取栈中有效元素个数

前面一直强调top就是有效元素个数，所以直接返回top的值即可。

int STSize(ST* ps)
{
	assert(ps);
	//返回top的值
	return ps->top;
}

（6）检测栈是否为空

由top来判断，top为零就是空栈返回true，否则返回false。

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

（7）销毁栈

数组空间是连续的，释放数组空间即可，然后将top和capacity置零。

void STDeastroy(ST* ps)
{
	assert(ps);
	//释放空间
	free(ps->a);
	//数组置空
	ps->a = NULL;
	//top和容量capacity置零
	ps->top = ps->capacity = 0;
}

二、队列

1.队列的概念及结构简析

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。
队列遵守先进先出FIFO(First In First Out) 的原则：
  进行插入操作的一端称为队尾；
  进行删除操作的一端称为队头。
结构图示：
请添加图片描述

2.队列的实现方式

队列可以用数组或链表实现
使用链表更优一些，使用数组的话出队列在数组头上出数据，之后每个数据都要往前移一位，效率会比较低，而链表出数据不需要大量移动数据。

3.队列的基本功能实现

（1）队列的结构体

队列的结构体成员一个是头指针，一个是尾指针（记录尾结点的），而链表的节点包括下一结点地址和自己的数据，所以可以再声明一个结构体来表示队列。
请添加图片描述

//重定义，方便后续更改存储数据的类型
typedef int QDataType;
//结点结构体
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
//队列结构体
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;

（2）队列的初始化

void QueueInit(Que* pq)
{
	//提前断言，阻止人为(我们)传空指针
	assert(pq);
	//头和尾都置空
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

（3）入队列出队列操作

  入队列：
注意事项：
1、入队列要先创建一个新结点，将传入数据存到这个新节点里，该新结点指针域置空；
2、注意新结点的链接和尾结点的更新；
3、单独处理空队列情况，否则就会出现解引用空指针的情况存在。

void QueuePush(Que* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	
	if (!newnode)
	{
		perror("malloc fail");
		exit(-1);
	}
	//创建新结点
	newnode->data = x;
	newnode->next = NULL;
	//队列为空，单独处理
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		//尾结点指针域指向新结点
		pq->tail->next = newnode;
		//尾结点更新为新结点
		pq->tail = newnode;
	}
	++pq->size;
}

  出队列：

注意事项：

1、先保存好原头结点的下一个结点，将下一节点记为新的头结点，然后释放原头结点，再将这个新的头结点更新为当前头结点；
2、执行出队列时，先检查队列是否为空；
3、多次置空后忘记置空尾结点，只置空了头结点，会造成野指针问题。

void QueuePop(Que* pq)
{
	assert(pq);
	//提前断言，阻止队列为空时传入
	assert(pq->head);
	//只有一个结点，删除该节点后将头和尾置空
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		//提前保留下一个位置
		QNode* next = pq->head->next;
		//释放当前结点
		free(pq->head);
		//继续下一个
		pq->head = next;
	}
	pq->size--;
}

（4）获取队头元素

直接返回头结点数据
注意事项：
队列为空时不能获取，否则会造成解引用空指针。

QDataType QueueFront(Que* pq)
{
	assert(pq);
	//断言，队列为空时阻止下一步操作
	assert(pq->head);
	//返回头结点数据
	return pq->head->data;
}

（5）获取队尾元素

直接返回尾结点数据
注意事项：
队列为空时不能获取，否则会造成解引用空指针。

QDataType QueueBack(Que* pq)
{
	assert(pq);
	//断言，队列为空时阻止下一步操作
	assert(pq->head);
	//返回尾结点数据
	return pq->tail->data;
}

（6）获取队列中有效元素个数

有两种实现方法：
1、在队列结构体中多声明一个size成员变量来记录，初始化为零，每次出入队列都更新；
2、尾结点地址减去头结点地址。

int QueueSize(Que* pq)
{
	//这里采用第二种方法
	assert(pq);
	return pq->tail - pq->head;
}

（7）检测队列是否为空

头结点为空，队列即为空

bool QueueEmpty(Que* pq)
{
	assert(pq);
	return pq->head == NULL;
}

（8）销毁队列

注意事项：
1、销毁队列和链表的销毁类似，都是从头结点开始往后一个一个删除；
请添加图片描述

2、释放当前结点时要注意记录下一个结点，否则会找不到下一个结点；
3、头和尾最后都要置空，否则会出现野指针问题。

void QueueDestroy(Que* pq)
{
	assert(pq);
	//先记录当前结点
	QNode* cur = pq->head;
	while (cur)
	{
		//先保存下一个结点
		QNode* next = cur->next;
		//再释放
		free(cur);
		//更新当前结点
		cur = next;
	}
	//头和尾都要置空
	pq->head = NULL;
	pq->tail = NULL;
	
	pq->size = 0;
}

三、栈和队列的完整代码参考

1.栈

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 STDeastroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
STDataType STTop(ST* ps);

int STSize(ST* ps);
bool STEmpty(ST* ps);
void Print(ST* ps);

Stack.c（功能实现）

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

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

void STDeastroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if(ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmpa = (STDataType*)realloc(ps->a, sizeof(STDataType)*newcapacity);
		if (!tmpa)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmpa;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	--ps->top;
}

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);

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

int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

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

void Print(ST* ps)
{
	assert(ps);
	while(ps->top>0)
	{
		printf("%d ", ps->a[ps->top-1]);
		ps->top--;
	}
}

可以自己编写测试代码，这里给出一个参考测试代码。

Stacktest.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

void test()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	STPush(&s, 5);
	STPush(&s, 6);
	Print(&s);
}
int main()
{
	test();

	return 0;
}

2.队列

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

void Print(Que* pq);

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#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* next = cur->next;
		free(cur);
		cur = next;
	}

	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)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	++pq->size;
}

void QueuePop(Que* pq)
{
	assert(pq);
	assert(pq->head);

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

QDataType QueueFront(Que* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}

QDataType QueueBack(Que* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->tail->data;
}

bool QueueEmpty(Que* pq)
{
	assert(pq);
	return pq->head == NULL;
}

int QueueSize(Que* pq)
{
	assert(pq);
	return pq->tail - pq->head;
}

void Print(Que* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
}

可以自己编写测试代码，这里给出一个参考测试代码。

Queuetest.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
int main()
{
	Que pq;
	QueueInit(&pq);
	QueuePush(&pq, 1);
	QueuePush(&pq, 2);

	QueuePush(&pq, 3);
	QueuePush(&pq, 4);
	QueuePush(&pq, 5);
	QueuePush(&pq, 6);
	QueuePush(&pq, 7);
	Print(&pq);
	return 0;
}
渣檬Charman
关注
c语言 栈和队列的实现
编程爱好者的博客
08-14 6718
前提知识 顺序表 优点：可以随机访问，cpu高速缓存利用率高，不涉及（较少）进行插入和删除操作，应该使用顺序表 一般而言，我们使用顺序表（数组）的形式建立 栈这一数据结构。   栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 其特点是先进后出，模仿c++stl的stack和queue，我...
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2297
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
C语言实现栈与队列
2301_79432671的博客
02-11 964
不直接定义一个数组，而采用realloc、malloc来动态管理顺序表大小，使栈的大小不再受限。再定义一个top栈顶指针来方便后续的增删操作。//将int类型重定义叫做MyDataType//一个MyDataType类型的指针，可以进行动态内存开辟//栈的最大容量int top;//用于栈顶指针}ST;队列是只允许在一端插入元素，另一端删除元素的线性表，特点是先进先出。Queue这个结构体中还包含两个QNode结点结构体。包含队列头尾结点，能够帮助从队尾插入和从队头删除。
栈和队列的实现
最新发布
m0_63703622的博客
08-29 809
栈和队列的知识点及实现
【C语言】栈与队列的实现
GMfengyi的博客
03-07 592
本文介绍了栈，队列两个数据结构的底层实现与操作函数的实现，
C语言——栈与队列的实现
weixin_40203143的博客
12-28 3066
栈与队列都是受限的线性表，均可以通过顺序表（数组）和链表两种方式得到实现。只不过栈是FILO，队列是FIFO，即栈和队列在出和入的方式上有所不同。而通过数组和链表实现的区别，即为数组与链表本身的区别：数组的存储空间是连续的，不可动态扩展；链表的存储空间是不连续的，可以动态扩展。下面具体来说。 一、栈的实现： 栈有栈底和栈顶，栈底是固定的，栈顶指向栈最顶上的第一个数据；数据的入栈和出栈只能在栈顶...
栈与队列的实现(C语言)
weixin_57604904的博客
11-04 219
栈与队列
C语言-数据结构-栈队列实现
03-10
这些文件共同构成了一个完整的C语言数据结构库，实现了栈和队列的基本操作，可以用于各种需要此类数据结构的计算机程序中。了解并熟练掌握这些基础知识对于任何想深入学习C语言或计算机科学的人来说都是至关重要的。
c语言数据结构-栈队列数组完美版资料.ppt
11-14
本资源摘要信息主要关于C语言数据结构中的栈、队列和数组三个基本概念。...栈、队列和数组是C语言数据结构中的三个基本概念，栈的实现需要考虑到实际情况，栈的应用非常广泛，栈的优点和缺点需要被正确地考虑。
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
C语言中栈和队列实现表达式求值的实例
08-29
栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值的实例。 栈是一种后进先出（LIFO）的...
C语言栈和队列代码实现
08-08
包含内容：栈、队列、循环队列的数组实现方式和链表实现方式
C语言实现栈和队列
Sun_student的博客
01-08 3101
一、栈（原理：FILO||LIFO）        实现思想：利用静态顺序表实现栈                      1.定义结构体，包含值和数组还有栈顶成员变量记录栈内元素个数（栈主要就是对栈顶元素的操作）                      2.初始化、销毁（比较简单看代码理解）                      3.增操作：先判断栈是否已满，再在栈顶进行添加；（...
栈和队列（C语言实现）
wsyjpgs的博客
06-04 156
栈和队列的C语言实现
C语言实现栈和队列(栈和队列的基本操作)
热门推荐
Damn_Yang的博客
11-10 11万+
栈： 栈：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 特点：先进后出 stack.h #pragma once #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;assert.h&gt; #include &lt;...
队列和栈(C语言)
wllen_的博客
07-30 2310
栈和队列的基本性质 栈是先进后出的结构（弹夹） 队列是先进先出的（排队） 栈和队列在实现结构上可以有数组和链表两种方式 栈结构的基本操作： 1、弹栈 2、访问栈顶元素 3、压栈操作 4、返回当前栈中的元素个数   队列结构的基本操作： 1、队列元素进队列是从队尾插入的 2、队列元素出队列是从对头弹出的             （类似于日常排队）    /*栈的结构定义（顺...
数据结构（用C语言描述）：栈和队列基本概念、实现
Ezra1991的博客
10-17 1158
栈和队列 栈 栈的基本概念 栈的定义 栈(Stack)：只允许在一端进行插入或删除操作的线性表。 栈顶(Top): 线性表允许进行插入和删除的那一端 栈底(Bottom): 固定的，不允许进行插入和删除操作的另一端。 空栈：不含任何元素的空表。 栈的一个明显的操作特性：后进先出(Last In First Out, LIFO),故又称为后进先出的线性表。 ...
C语言 | 队列实现栈
张登雨的博客
03-27 141
力扣225题 /* 构造队列结构 */ #define LEN 20 typedef struct queue { int* data; int head; int rear; int size; } Queue; /* 初始化队列 */ Queue* initQueue(int k) { Queue* obj = (Queue*)malloc(sizeof(Queue)); obj->data = (int*)malloc(sizeof(int) *
使用队列实现栈——基于C语言
qq_38705421的博客
08-13 425
今天使用之前实现的队列实现栈。 下面是Main.c文件; #include "QueueToStack.h" #include <stdio.h> int main() { QueueToStack* stack = QueueToStackCreate(); if(stack != NULL) { int i, len = -1, data = -1; for(i = 0; i < 100; i++) { QueueToStackPush(stack,
C语言实现数据结构：栈和队列操作详解
资源摘要信息: 本文档详细介绍了数据结构中栈和队列的概念、操作及C语言实现。栈是一种后进先出（LIFO）的数据结构，支持两种主要操作：push（入栈）和pop（出栈），以及辅助操作如获取栈顶元素和打印栈内容。队列是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值