（数据结构初阶）栈和队列

已于 2022-06-19 12:51:26 修改
阅读量222 收藏
点赞数
分类专栏： C/C++学习笔记 文章标签： 数据结构
于 2022-06-19 12:48:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57594025/article/details/125354756
版权

目录

一 栈

1.栈的基本概念

2.栈的核心接口代码实现

         3.栈的代码实现（完整）

二 队列

1.队列的基本概念

2.队列核心接口的实现

3.队列的实现（全部）

一 栈

1.栈的基本概念

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

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

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

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

2.栈的核心接口代码实现

（1）基本结构

typedef int STDateType;
struct Stack
{
	STDateType* a;
	int top;       //栈顶
	int capacity;  //容量
};
//typedef struct Stack  ST;
typedef struct Stack  Stack;

（2）初始化

//初始化
void StackInit(Stack* pst)
{
	assert(pst);

	pst->a = (STDateType*)malloc(sizeof(STDateType)*4);
	pst->top = 0;
	pst->capacity = 4;
}

（3）销毁

//销毁
void StackDestroy(Stack* pst)
{
	assert(pst);

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

（4）入栈

//压栈（性质就决定了在栈顶出入数据）
void StackPush(Stack* pst, STDateType x)
{
	assert(pst);

	if (pst->capacity == pst->top)
	{
		STDateType* temp = realloc(pst->a,sizeof(STDateType)*pst->capacity*2);
		if (NULL == temp)
		{
			printf("realloc fail \n");
			exit(-1);
		}
		pst->a = temp;
		pst->capacity *= 2;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

（5）出栈

//弹栈
void StackPop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

	pst->top--;

}

（6）取栈顶位置数据

//取数据
STDateType StackTop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

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

（7）判断栈是否为空

//空返回1，非空返回0
bool StackEmpty(Stack* pst)
{
	assert(pst);
    
	return pst->top == 0;
}

（8）求栈的长度

//求栈的长度
int StackSize(Stack* pst)
{
	assert(pst);

	return pst->top;
}

3.栈的代码实现（完整）

（1）stack.h

#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int STDateType;
struct Stack
{
	STDateType* a;
	int top;       //栈顶
	int capacity;  //容量
};
//typedef struct Stack  ST;
typedef struct Stack  Stack;

void StackInit(Stack* pst); //初始化
void StackDestroy(Stack* pst);//销毁

//性质就决定了在栈顶出入数据
void StackPush(Stack* pst, STDateType x);//压栈
void StackPop(Stack* pst);//弹栈

STDateType StackTop(Stack* pst);//取数据

//空返回1，非空返回0
bool StackEmpty(Stack* pst);
int StackSize(Stack* pst); //求栈的容量

（2）stack.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"stack.h"

//初始化
void StackInit(Stack* pst)
{
	assert(pst);

	pst->a = (STDateType*)malloc(sizeof(STDateType)*4);
	pst->top = 0;
	pst->capacity = 4;
}

//销毁
void StackDestroy(Stack* pst)
{
	assert(pst);

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

//压栈（性质就决定了在栈顶出入数据）
void StackPush(Stack* pst, STDateType x)
{
	assert(pst);

	if (pst->capacity == pst->top)
	{
		STDateType* temp = realloc(pst->a,sizeof(STDateType)*pst->capacity*2);
		if (NULL == temp)
		{
			printf("realloc fail \n");
			exit(-1);
		}
		pst->a = temp;
		pst->capacity *= 2;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

//弹栈
void StackPop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

	pst->top--;

}

//取数据
STDateType StackTop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

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

//空返回1，非空返回0
bool StackEmpty(Stack* pst)
{
	assert(pst);
    
	return pst->top == 0;
}

//求栈的长度
int StackSize(Stack* pst)
{
	assert(pst);

	return pst->top;
}

（3）test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"stack.h"

void test()
{
	Stack st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPush(&st, 5);

	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}

	StackDestroy(&st);
}

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

二 队列

1.队列的基本概念

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

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

2.队列核心接口的实现

（1）队列的结构

typedef int QDateType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDateType date;
}QueueNode;

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

（2）初始化

//初始化
void QueueInit(Queue* pq)
{
	pq->head = pq->tail = NULL;
}

（3）销毁

//销毁
void QueueDestroy(Queue* pq)
{
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

（4）入队

//入队
void QueuePush(Queue* pq, QDateType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (NULL == newnode)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->date = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

（5）出队

//出队
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (NULL == pq->head->next)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QueueNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

（6）取队头数据

//取队头数据
QDateType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->date;
}

（7）取队尾数据

//取队尾数据
QDateType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->date;
}

（8）判断队列是否为空

//空返回 false  不为空返回 true
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL;
}

（9）队列长度

//队列长度
int Queuesize(Queue* pq)
{
	int size = 0;
	QueueNode* cur = pq->head;
	while(cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

3.队列的实现（全部）

（1）queue.h

#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int QDateType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDateType date;
}QueueNode;

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);

void QueuePush(Queue* pq, QDateType x);
void QueuePop(Queue* pq);

QDateType QueueFront(Queue* pq);
QDateType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int Queuesize(Queue* pq);

（2）queue.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"queue.h"

//初始化
void QueueInit(Queue* pq)
{
	pq->head = pq->tail = NULL;
}

//销毁
void QueueDestroy(Queue* pq)
{
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

//入队
void QueuePush(Queue* pq, QDateType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (NULL == newnode)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->date = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

//出队
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (NULL == pq->head->next)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QueueNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

//取队头数据
QDateType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->date;
}

//取队尾数据
QDateType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->date;
}

//空返回 false  不为空返回 true
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL;
}

//队列长度
int Queuesize(Queue* pq)
{
	int size = 0;
	QueueNode* cur = pq->head;
	while(cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

（3）test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"queue.h"

void text()
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

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

	QueueDestroy(&q);
}

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

Zhang丶&｜！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构初阶数据结构初阶
02-12
初学者在学习数据结构时，通常会遇到一系列基础概念和重要类型，这些都会在"数据结构初阶"的学习中逐步揭示。 首先，我们要理解数据结构的基本概念。数据结构是存储和组织数据的一种方式，它不仅考虑了数据的存储，...
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-24
基础的数据结构通常包括数组、链表、栈和队列。 1. **数组**：数组是最基本的数据结构，它是一种线性数据结构，其中元素存储在连续的内存位置中。数组的优点是可以通过索引来快速访问元素，但插入和删除操作可能...
数据结构初阶：栈和队列
yourfriendyo的博客
11-05 836
文章目录栈和队列1 栈1.1 栈的定义和结构栈结构体定义1.2 栈的实现栈初始化和销毁栈的压入和弹出获取栈顶元素其他基本接口2 队列2.1 队列的定义和结构队列结构体定义2.2 队列的实现队列初始化和销毁队尾入队和队头出队获取队头队尾元素其他基本接口3 栈和队列面试题Example 1 有效括号Example 2 队列实现栈Example 3 栈实现队列Example 4 循环队列 栈和队列 栈和队列都是数据结构的一种，本章利用线性表来模拟实现栈和队列这两种结构。 1 栈 1.1 栈的定义和结构 栈是一
数据结构初阶（栈和队列）
wuweixiaoyue的博客
04-27 507
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。出栈：栈的删除操作叫做出栈。出数据在栈顶。JVM虚拟机栈 VS 栈JVM虚拟机栈：系统的一块内存栈：数据结构队列。
初阶数据结构之栈和队列
yyy_3yu的博客
07-22 564
栈和队列是两种特殊的线性表，都可以用数组或者链表来实现，接下来就让我们看看栈和队列会有什么奥秘吧~
数据结构初阶——栈和队列
m0_64607843的博客
05-23 4760
学了顺序表，学了链表不过瘾，那就进来看看栈和队列吧，当饭后水果还是不错滴！！！
数据结构初阶：栈与队列
weixin_63143943的博客
07-15 439
栈与队列的基本操作
【数据结构初阶】栈和队列
2201_75642960的博客
11-22 1968
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。通读全文的你肯定收获满满，让我们继续为数据结构学习共同奋进!栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为。队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有。FIFO(First In First Out) 入队列：进行插入操作的一端称为。压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
初阶数据结构3 栈和队列
Yusei_0523的博客
08-01 876
栈和队列
初阶数据结构—栈和队列
Awkwardx的博客
05-23 1128
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。压栈：栈的插入操作叫做进栈/压栈/入栈，。出栈：栈的删除操作叫做出栈。。
数据结构初阶 栈和队列的实现 个人随堂笔记
qq_68225689的博客
10-16 109
数据结构初阶 栈和队列的实现 个人随堂笔记
初阶数据结构 — 栈和队列
LeEKyee的博客
05-12 123
队列：只允许在一端进行插入数据操作在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头。
C语言实现数据结构算法初阶算法
06-15
5. **队列**：队列是一种先进先出（FIFO）的数据结构，适用于任务调度和消息传递。C语言中，队列可由数组（循环队列）或链表实现，常用的操作有enqueue（入队）和dequeue（出队）。 6. **二叉树遍历**：二叉树是一...
java数据结构和算法
03-04
数据结构是组织和管理大量数据的方式，它包括数组、链表、栈、队列、哈希表、树（如二叉树、红黑树）、图等。理解这些数据结构能帮助我们更有效地存储和检索数据，优化程序性能。例如： 1. **数组**：是最基础的...
数据结构之树的存储结构
最新发布
DKPT的博客
08-16 512
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
二叉树详解（1）
weixin_73077334的博客
08-15 1278
二叉树详解（1）
【数据结构】二叉树篇
2303_79015671的博客
08-14 1350
深入解析数据结构二叉树
数据结构之排序（下）
qq_74336191的博客
08-15 677
​ 嗨！小伙伴们，咱们又见面啦，在上一篇数据结构之排序（上）中，我们学习了直接插入排序、冒泡排序和希尔排序，今天我们继续学习排序这一块，准备好了吗？Ready Go ! ! ! ​
链表 19.删除链表的倒数第N个节点 双指针
qq_64633597的博客
08-14 233
return head 和return dummy.next 的区别，若删除的是头节点，则头节点还需要更新，题目中给的头节点就不能用了。而dummy作为虚拟头节点，永远是头节点的上一位，即使head发生变化，仍然是dummy.next。fast走n+1步，是为了和slow保持n+1个位置，此时fast移动至空节点，slow与fast位置差n+1节点，那slow再往后移动一位，就是需要删除的倒数第n个节点，即目标节点。倒数第几个，翻过来看即正数第几个。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zhang丶&｜！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值