栈和队列

于 2023-05-15 15:40:23 发布
阅读量90 收藏
点赞数
文章标签： c++ 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43936465/article/details/130685958
版权

栈的顺序存储

  • 利用数组模拟出 栈的陷阱后出的数据结构

栈的设计

栈的结构体

#define MAX 1024
struct SStack
{
	// 栈中数组
	void* data[MAX];
	
	// 栈大小
	int m_Size;
};

typedef void* SeqStack;

初始化栈

SeqStack init_SeqStack()
{
	struct SStack* myStack = malloc(sizeof(struct SStack));
	if (myStack == NULL)
	{
		return NULL;
	}

	memset(myStack->data, 0, sizeof(void*) * MAX);
	myStack->m_Size = 0;

	return myStack;
}

入栈

void push_SeqStack(SeqStack stack, void* data)
{
	// 本质 数组尾插
	if (stack == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	struct SStack* myStack = stack;

	// 判断栈是否满
	if (myStack->m_Size == MAX)
	{
		return;
	}

	// 数组尾插
	myStack->data[myStack->m_Size] = data;

	// 更新数组大小
	myStack->m_Size++;
}

出栈

void pop_SeqStack(SeqStack stack)
{
	// 本质 数组尾删
	if (stack == NULL)
	{
		return;
	}

	struct SStack* myStack = stack;

	if (myStack->m_Size == 0)
	{
		return;
	}

	// 数组尾删
	myStack->data[myStack->m_Size] = NULL;
	// 更新栈大小
	myStack->m_Size--;
}

返回栈顶

void* top_SeqStack(SeqStack stack)
{
	// 本质 返回数组中最后一个元素
	if (stack == NULL)
	{
		return;
	}

	struct SStack* myStack = stack;

	if (myStack->m_Size == 0)
	{
		return;
	}

	return myStack->data[myStack->m_Size - 1];
}

返回栈大小

int size_SeqStack(SeqStack stack)
{

	if (stack == NULL)
	{
		return -1;
	}
	struct SStack* myStack = stack;

	return myStack->m_Size;
}

判断栈是否为空

int isEmpty_SeqStack(SeqStack stack)
{
	if (stack == NULL)
	{
		return -1; // 传入空指针, 返回真, 也是空
	}
	struct SStack* myStack = stack;

	return myStack->m_Size == 0;
}

销毁栈

void destroy_SeqStack(SeqStack stack)
{
	if (stack == NULL)
	{
		return;
	}
	free(stack);
	stack = NULL;
}

测试

struct Person
{
	char name[64];
	int age;
};

// 测试栈
void test01()
{
	// 创建栈
	SeqStack myStack = init_SeqStack();

	// 创建数据
	struct Person p1 = { "aaa",18 };
	struct Person p2 = { "bbb",19 };
	struct Person p3 = { "ccc",16 };
	struct Person p4 = { "ddd",13 };
	struct Person p5 = { "eee",14 };
	struct Person p6 = { "fff",20 };

	// 入栈
	push_SeqStack(myStack, &p1);
	push_SeqStack(myStack, &p2);
	push_SeqStack(myStack, &p3);
	push_SeqStack(myStack, &p4);
	push_SeqStack(myStack, &p5);
	push_SeqStack(myStack, &p6);

	printf("栈的大小: %d\n", size_SeqStack(myStack));
	while (isEmpty_SeqStack(myStack) == 0) // 栈不为空, 开始查看栈顶元素, 并且出栈
	{
		struct Person* pTop = top_SeqStack(myStack);
		printf("name: %s, age: %d\n", pTop->name, pTop->age);
		// 出栈
		pop_SeqStack(myStack);
		printf("栈的大小: %d\n", size_SeqStack(myStack));
	}

	destroy_SeqStack(myStack);
}

栈的链式存储

设计

  • 链表头节点 做栈顶, 用于进出数据

节点结构体

// 节点结构体
struct LinkNode
{
	// 只维护指针域
	struct LinkNode* next;
};

栈的结构体

// 栈结构体
struct LStack
{
	// 头节点
	struct LinkNode pHeader;
	// 栈大小
	int m_Size;
};

typedef void* LinkStack;

初始化栈

LinkStack init_LinkStack()
{
	struct LStack * myStack = malloc(sizeof(struct LStack));

	if (myStack == NULL)
	{
		return NULL;
	}
	myStack->pHeader.next = NULL;
	myStack->m_Size = 0;

	return myStack;
}

入栈

void push_LinkStack(LinkStack stack, void* data)
{
	// 本质 链表头插
	if (stack == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}

	struct LStack* myStack = stack;

	// 取出用户数据前四个字节
	struct LinkNode* myNode = data;

	myNode->next = myStack->pHeader.next;
	myStack->pHeader.next = myNode;

	myStack->m_Size++;
}

出栈

void pop_LinkStack(LinkStack stack)
{
	// 本质 链表头删
	if (stack == NULL)
	{
		return;
	}

	struct LStack* myStack = stack;

	if (myStack->m_Size == 0)
	{
		return;
	}

	// 创建指向第一个节点的指针
	struct LinkNode* pFirst = myStack->pHeader.next;
	// 更新节点指向
	myStack->pHeader.next = pFirst->next;
	// 更新栈大小
	myStack->m_Size--;
}

返回栈顶

void* top_LinkStack(LinkStack stack)
{
	if (stack == NULL)
	{
		return;
	}
	struct LStack* myStack = stack;

	if (myStack->m_Size == 0)
	{
		return;
	}

	return myStack->pHeader.next;
}

返回栈大小

int size_LinkStack(LinkStack stack)
{
	if (stack == NULL)
	{
		return -1;
	}
	struct LStack* myStack = stack;

	return myStack->m_Size;
}

判断栈是否为空

int isEmpty_LinkStack(LinkStack stack)
{
	if (stack == NULL)
	{
		return -1;
	}
	struct LStack* myStack = stack;

	return myStack->m_Size == 0;
}

销毁栈

void destroy_LinkStack(LinkStack stack)
{
	if (stack == NULL)
	{
		return ;
	}

	free(stack); 
	stack = NULL;
}

测试

struct Person
{
	char* a;
	char name[64];
	int age;
};

// 测试栈
void test01()
{
	// 创建栈
	LinkStack myStack = init_LinkStack();

	// 创建数据
	struct Person p1 = {NULL, "aaa",18 };
	struct Person p2 = {NULL, "bbb",19 };
	struct Person p3 = {NULL, "ccc",16 };
	struct Person p4 = {NULL, "ddd",13 };
	struct Person p5 = {NULL, "eee",14 };
	struct Person p6 = {NULL, "fff",20 };

	// 入栈
	push_LinkStack(myStack, &p1);
	push_LinkStack(myStack, &p2);
	push_LinkStack(myStack, &p3);
	push_LinkStack(myStack, &p4);
	push_LinkStack(myStack, &p5);
	push_LinkStack(myStack, &p6);

	printf("栈的大小: %d\n", size_LinkStack(myStack));
	while (isEmpty_LinkStack(myStack) == 0) // 栈不为空, 开始查看栈顶元素, 并且出栈
	{
		struct Person* pTop = top_LinkStack(myStack);
		printf("LinkStack name: %s, age: %d\n", pTop->name, pTop->age);
		// 出栈
		pop_LinkStack(myStack);
		printf("栈的大小: %d\n", size_LinkStack(myStack));
	}

	destroy_LinkStack(myStack);
}

队列的顺序存储

  • 利用数组模拟出队列

设计

初始化队列

SeqQueue init_SeqQueue()
{
	// 动态数组 初始化
	struct dynamicArray* array  = init_dynamicArray(MAX);

	return array;
}

入队

void push_SeqQueue(SeqQueue queue, void* data)
{
	// 本质 尾插
	if (queue == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}

	struct dynamicArray* array = queue;

	if (array->m_Size == MAX)
	{
		return;
	}

	// 动态数组 插入数据
	insert_dynamicArray(array, data, array->m_Size);

}

出队

void pop_SeqQueue(SeqQueue queue)
{
	// 本质 头删
	if (queue == NULL)
	{
		return;
	}
	struct dynamicArray* array = queue;

	if (array->m_Size == 0)
	{
		return;
	}
	// 动态数组 按指定位置删除数据
	removeByPos_dynamicArray(array, 0);
}

返回队头

void* front_SeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	struct dynamicArray* array = queue;
	
	return array->pAddr[0];
}

返回队尾

void* back_SeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	struct dynamicArray* array = queue;

	return array->pAddr[array->m_Size-1];
}

返回队列大小

int size_SeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	struct dynamicArray* array = queue;

	return array->m_Size;
}

判断队列是否为空

int isEmpty_SeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	struct dynamicArray* array = queue;
	
	return array->m_Size == 0;
}

销毁队列

void destroy_SeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return ;
	}

	// 动态数组 销毁数组
	destroy_dynamicArray(queue);
}

测试

// 测试队列
struct Person
{
	char name[64];
	int age;
};

void test01()
{
	// 初始化队列
	SeqQueue queue = init_SeqQueue();

	// 创建数据
	struct Person p1 = { "aaa",10 };
	struct Person p2 = { "bbb",11 };
	struct Person p3 = { "ccc",12 };
	struct Person p4 = { "ddd",13 };
	struct Person p5 = { "eee",14 };

	// 入队
	push_SeqQueue(queue, &p1);
	push_SeqQueue(queue, &p2);
	push_SeqQueue(queue, &p3);
	push_SeqQueue(queue, &p4);
	push_SeqQueue(queue, &p5);

	// 通过循环查看队头 队尾 执行出队
	while (isEmpty_SeqQueue(queue) == 0) // 不为空
	{
		struct Person * pFront  = front_SeqQueue(queue);
		printf(" Front name: %s, age: %d\n", pFront->name, pFront->age);

		struct Person* pBack = back_SeqQueue(queue);
		printf(" Back name: %s, age: %d\n", pBack->name, pBack->age);

		// 出队
		pop_SeqQueue(queue);

		//printf("size: %d\n", size_SeqQueue(queue));
	}

	// 销毁队列

	destroy_SeqQueue(queue);
}

队列的链式存储

  • 利用链表模拟队列

设计

// 节点结构体
struct LinkNode
{
	struct LinkNode* next;
};

// 队列结构体
struct LQueue
{
	// 头节点
	struct LinkNode pHeader;
	// 队列大小
	int m_Size;
	// 尾节点指针
	struct LinkNode* pTail;
};


typedef void* LinkQueue;

初始化

LinkQueue init_LinkQueue()
{
	struct LQueue* queue = malloc(sizeof(struct LQueue));
	if (queue == NULL)
	{
		return NULL;
	}

	queue->pHeader.next = NULL;
	queue->m_Size = 0;
	queue->pTail = &queue->pHeader;

	return queue;
}

入队

void push_LinkQueue(LinkQueue queue, void* data)
{ 
	// 本质 尾插
	if (queue == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	// 还原队列的真实结构体
	struct LQueue* myQueue = queue;

	// 用户数据前4个字节取出
	struct LinkNode* myNode = data;

	// 更改指针指向
	myQueue->pTail->next = myNode;
	myNode->next = NULL;
	myQueue->pTail = myNode;

	// 更新队列大小
	myQueue->m_Size++;
}

出队

void pop_LinkQueue(LinkQueue queue)
{
	// 本质 头删
	if (queue == NULL)
	{
		return;
	}
	// 还原队列的真实结构体
	struct LQueue* myQueue = queue;

	if (myQueue->m_Size == 0)
	{
		return;
	}

	// 如果只有1个节点, 更新尾节点的位置
	if (myQueue->m_Size == 1)
	{
		myQueue->pHeader.next = NULL;
		myQueue->pTail = &(myQueue->pHeader);
		myQueue->m_Size--;
		return;
	}

	// 记录第一个有数据的节点
	struct LinkNode* pFirt = myQueue->pHeader.next;

	// 更改指针指向
	myQueue->pHeader.next = pFirt->next;


	// 更新队列大小
	myQueue->m_Size--;
}

返回队头元素

void* front_LinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	// 还原队列的真实结构体
	struct LQueue* myQueue = queue;

	if (myQueue->m_Size == 0)
	{
		return NULL;
	}

	return myQueue->pHeader.next;
}

返回队尾元素

void* back_LinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	// 还原队列的真实结构体
	struct LQueue* myQueue = queue;

	if (myQueue->m_Size == 0)
	{
		return NULL;
	}

	return myQueue->pTail;
}

返回队列大小

int size_LinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	// 还原队列的真实结构体
	struct LQueue* myQueue = queue;

	return myQueue->m_Size;
}

判断队列是否为空

int isEmpty_LinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	// 还原队列的真实结构体
	struct LQueue* myQueue = queue;

	return myQueue->m_Size == 0;
}

销毁队列

void destroy_LinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return;
	}
	free(queue);
	queue = NULL;
}

测试

// 测试队列
struct Person
{
	char* a;
	char name[64];
	int age;
};

void test01()
{
	// 初始化队列
	LinkQueue queue = init_LinkQueue();

	// 创建数据
	struct Person p1 = { NULL,"aaa",10 };
	struct Person p2 = { NULL,"bbb",11 };
	struct Person p3 = { NULL,"ccc",12 };
	struct Person p4 = { NULL,"ddd",13 };
	struct Person p5 = { NULL,"eee",14 };

	// 入队
	push_LinkQueue(queue, &p1);
	push_LinkQueue(queue, &p2);
	push_LinkQueue(queue, &p3);
	push_LinkQueue(queue, &p4);
	push_LinkQueue(queue, &p5);

	// 通过循环查看队头 队尾 执行出队
	while (isEmpty_LinkQueue(queue) == 0) // 不为空
	{
		struct Person* pFront = front_LinkQueue(queue);
		printf(" Front name: %s, age: %d\n", pFront->name, pFront->age);

		struct Person* pBack = back_LinkQueue(queue);
		printf(" Back name: %s, age: %d\n", pBack->name, pBack->age);

		// 出队
		pop_LinkQueue(queue);

		printf("size: %d\n", size_LinkQueue(queue));
	}

	// 销毁队列

	destroy_LinkQueue(queue);
}
妄จุ๊บ
关注
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
zhanheduilie.rar_栈和队列
09-24
栈和队列是计算机科学中基础且重要的数据结构，它们在程序设计中有着广泛的应用。在本资料"zhanheduilie.ppt"中，详细讲述了这两种数据结构的原理、特性以及实际应用。 栈（Stack）是一种后进先出（LIFO, Last In ...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
栈和队列笔记包括栈和队列的定义、顺序栈出入栈、链栈的出入栈操作、顺序队列基本操作、链式队列基本操作等
最新发布
04-03
### 栈和队列知识点详解 #### 一、栈的定义 栈是一种特殊的线性数据结构，其特点是只允许在一端进行数据的插入和删除操作，遵循“先进后出”(First In Last Out, FILO)的原则。在这个数据结构中，最新加入的数据...
栈和队列的基本操作
01-02
"栈和队列的基本操作" 栈和队列是计算机科学中两个基本的数据结构，它们的基本操作包括进栈、出栈、进队、出队等。栈是一种后进先出的数据结构，即最后一个入栈的元素将是第一个出栈的元素。队列是一种先进先出的...
数据结构栈和队列
04-08
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
栈和队列PPT
05-23
栈和队列PPT课件，想要了解栈和队列的同学，可以下载一下。
栈和队列源代码
06-18
在计算机科学中，栈和队列是两种基本的数据结构，它们在编程中有着广泛的应用。栈被称为“后进先出”（LIFO, Last In First Out）数据结构，而队列则是“先进先出”（FIFO, First In First Out）数据结构。这两种...
数据结构栈和队列（参考代码）
06-18
### 数据结构栈和队列知识点解析 #### 一、栈的基本概念与操作 **栈**是一种特殊的线性表，只允许在一端进行插入和删除操作，这一端被称为栈顶，另一端被称为栈底。栈遵循先进后出（First In Last Out, FILO）的...
zhangheduilie_currentqcb_栈和队列_
10-01
在IT领域，栈和队列是两种非常基础且重要的数据结构，它们在计算机科学和软件开发中扮演着不可或缺的角色。栈通常被称为“后进先出”（LIFO, Last In First Out）的数据结构，而队列则被称为“先进先出”（FIFO, ...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
栈和队列详解
06-17
"栈和队列详解" 栈和队列是数据结构中两个基本的数据结构概念，本文将详细介绍栈和队列的定义、原理、操作和应用。 栈的定义和原理 栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构，栈中的元素按照加入...
stack-and-queue-.zip_栈和队列
09-14
栈和队列是两种最基本且常用的数据结构，它们在程序设计中扮演着重要角色。本篇文章将详细探讨这两种数据结构以及它们在实际应用中的作用。 栈（Stack）是一种“后进先出”（Last In, First Out，简称LIFO）的数据...
02-栈和队列.zip
01-31
栈和队列是数据结构中的基础概念，它们在计算机科学和编程中扮演着重要的角色。在深入探讨这两个概念之前，让我们先理解它们的基本定义。 栈（Stack）是一种后进先出（Last In First Out，简称LIFO）的数据结构。这...
栈和队列 实验报告
11-03
实验报告——栈和队列 一、实验目的 本次实验的主要目标是深入理解和熟练掌握两种基本数据结构——栈和队列的实现。首先，通过编程实现顺序栈，旨在熟悉栈的“后进先出”（LIFO）特性，以及相关的操作如初始化、...
栈和队列的操作
03-07
实验三 栈和队列的操作 1. 实验目的： 1）掌握栈的顺序存储结构和链式存储结构； 2）掌握队列的顺序存储结构； 3）验证栈和队列的基本操作实现。 2. 实验内容： 1）编程实现栈的以下基本操作：建栈，取栈顶元素，...
栈和队列操作实现
"该资源是关于栈和队列的数据结构练习，包含C语言实现的代码，涉及栈的入栈、出栈以及队列的入队、出队等基本操作。" 在计算机科学中，栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据时遵循特定...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值