队列和栈的实现

最新推荐文章于 2024-06-23 15:32:54 发布
最新推荐文章于 2024-06-23 15:32:54 发布
阅读量1k 收藏 8
点赞数 12
分类专栏： 数据结构和算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45526401/article/details/139577820
版权

文章目录

队列

队列的定义

 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。
在这里插入图片描述
队头（Front）：允许删除的一端，又称队首。
队尾（Rear）：允许插入的一端。
空队列：不包含任何元素的空表。

队列常见的基本操作

nitQueue(&Q)：初始化队列，构造一个空队列Q。
QueueEmpty(Q)：判队列空，若队列Q为空返回true，否则返回false。
EnQueue(&Q, x)：入队，若队列Q未满，将x加入，使之成为新的队尾。
DeQueue(&Q, &x)：出队，若队列Q非空，删除队头元素，并用x返回。
GetHead(Q, &x)：读队头元素，若队列Q非空，则将队头元素赋值给x。

队列的顺序存储结构

初始状态（队空条件）：Q->front == Q->rear == 0。
进队操作：队不满时，先送值到队尾元素，再将队尾指针加1。
出队操作：队不空时，先取队头元素值，再将队头指针加1。
在这里插入图片描述

实现

SeqQueue.h

#pragma once
#ifndef SEQQUEUE_H
#define SEQQUEUE_H

#define MAX_SIZE 1024

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

typedef struct SEQQUEUE_H {
	void* data[MAX_SIZE];
	int size;
}SeqQueue;

//初始化 //入列//返回队头元素//出队//返回队尾元素//返回大小//清空队列//销毁
SeqQueue* Init_SeqQueue();
//入列
void Push_SeqQueue(SeqQueue* queue, void* data);
//返回队头元素
void* Front_SeqQueue(SeqQueue* queue);
//出队
void Pop_SeqQueue(SeqQueue* queue);
//返回队尾元素
void* Back_SeqQueue(SeqQueue* queue);
//返回大小
int Size_SeqQueue(SeqQueue* queue);
//清空队列
void Clear_SeqQueue(SeqQueue* queue);
//销毁
void FreeSpace_SeqQueue(SeqQueue* queue);

#endif // !SEQQUEUE_H

SeqQueue.c

#include "SeqQueue.h"

//初始化 //入列//返回队头元素//出队//返回队尾元素//返回大小//清空队列//销毁
SeqQueue* Init_SeqQueue()
{
	SeqQueue* queue = (SeqQueue*)malloc(sizeof(SeqQueue));
	for (int i = 0; i < MAX_SIZE; i++)
	{
		queue->data[i] = NULL;
	}
	queue->size = 0;

	return queue;
}

//入列
void Push_SeqQueue(SeqQueue* queue, void* data)
{
	if (!queue || !data)
	{
		return;
	}

	if (queue->size == MAX_SIZE)
	{
		return;
	}

	queue->data[queue->size] = data;
	queue->size++;
}

//返回队头元素
void* Front_SeqQueue(SeqQueue* queue)
{
	if (!queue)
	{
		return NULL;
	}

	if (queue->size == 0)
	{
		return NULL;
	}

	return queue->data[0];
}

//出队
void Pop_SeqQueue(SeqQueue* queue)
{
	if (!queue)
	{
		return;
	}

	if (queue->size == 0)
	{
		return;
	}

	for (int i = 0; i < queue->size - 1; i++)
	{
		queue->data[i] = queue->data[i + 1];
	}

	queue->size--;
}

//返回队尾元素
void* Back_SeqQueue(SeqQueue* queue)
{
	if (!queue)
	{
		return NULL;
	}

	if (queue->size == 0)
	{
		return NULL;
	}

	return queue->data[queue->size - 1];
}

//返回大小
int Size_SeqQueue(SeqQueue* queue)
{
	if (!queue)
	{
		return -1;
	}

	return queue->size;
}

//清空队列
void Clear_SeqQueue(SeqQueue* queue)
{
	if (!queue)
	{
		return;
	}

	queue->size = 0;
}

//销毁
void FreeSpace_SeqQueue(SeqQueue* queue)
{
	if (!queue)
	{
		return;
	}

	free(queue);
}

main.c

#include "SeqQueue.h"

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

int main()
{
	//创建队列
	SeqQueue* queue = Init_SeqQueue();
	//创建数据
	Person p1 = { "aaa", 10 };
	Person p2 = { "bbb", 20 };
	Person p3 = { "ccc", 30 };
	Person p4 = { "ddd", 40 };
	Person p5 = { "eee", 50 };

	//数据入队列
	Push_SeqQueue(queue, &p1);
	Push_SeqQueue(queue, &p2);
	Push_SeqQueue(queue, &p3);
	Push_SeqQueue(queue, &p4);
	Push_SeqQueue(queue, &p5);

	//输出队尾元素
	Person* backPerson = (Person*)Back_SeqQueue(queue);
	printf("队尾元素：Name:%s, Age:%d\n", backPerson->name, backPerson->age);

	while (Size_SeqQueue(queue))
	{
		//取出队头元素
		Person* p = (Person*)Front_SeqQueue(queue);
		printf("Name:%s, Age:%d\n", p->name, p->age);
		//从队头弹出
		Pop_SeqQueue(queue);
	}

	FreeSpace_SeqQueue(queue);
	return 0; 
}

在这里插入图片描述

栈

栈的定义

 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。
在这里插入图片描述
栈顶（Top）：线性表允许进行插入删除的那一端。
栈底（Bottom）：固定的，不允许进行插入和删除的另一端。
空栈：不含任何元素的空表。
栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。

栈的常见基本操作

InitStack(&S)：初始化一个空栈S。
StackEmpty(S)：判断一个栈是否为空，若栈为空则返回true，否则返回false。
Push(&S, x)：进栈（栈的插入操作），若栈S未满，则将x加入使之成为新栈顶。
Pop(&S, &x)：出栈（栈的删除操作），若栈S非空，则弹出栈顶元素，并用x返回。
GetTop(S, &x)：读栈顶元素，若栈S非空，则用x返回栈顶元素。
DestroyStack(&S)：栈销毁，并释放S占用的存储空间（“&”表示引用调用）。

栈的顺序存储

 采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶元素的位置。
若存储栈的长度为StackSize，则栈顶位置top必须小于StackSize。当栈存在一个元素时，top等于0，因此通常把空栈的判断条件定位top等于-1。

实现

SeqStack.h

#pragma once
#ifndef SEQSTACK_H
#define SEQSTACK_H

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

//数组去模拟栈的顺序存储
#define MAX_SIZE 1024
#define SEQSTACK_TRUE 1
#define SEQSTACK_FALSE 0

typedef struct SEQSTACK {
	void* data[MAX_SIZE];
	int size;
}SeqStack;

//初始化栈 
SeqStack* Init_SeqStack();
//入栈
void Push_SeqStack(SeqStack* stack, void* data);
//返回栈顶元素
void* Top_SeqStack(SeqStack* stack);
//出栈
void Pop_SeqStack(SeqStack* stack);
//判断是否为空
int IsEmpty(SeqStack* stack);
//返回栈中元素的个数
int Size_SeqStack(SeqStack* stack);
//清空栈
void Clear_SeqStack(SeqStack* stack);
//销毁
void FreeSpace_SeqStack(SeqStack* stack);
#endif // !SEQSTACK_H

SeqStack.c

#include "SeqStack.h"

//初始化栈 
SeqStack* Init_SeqStack()
{
	SeqStack* stack = (SeqStack*)malloc(sizeof(SeqStack));

	for (int i = 0; i < MAX_SIZE; i++)
	{
		stack->data[i] = NULL;
	}
	stack->size = 0;

	return stack;
}

//入栈
void Push_SeqStack(SeqStack* stack, void* data)
{
	if (!stack || !data)
	{
		return;
	}

	if (stack->size == MAX_SIZE)
	{
		return;
	}

	stack->data[stack->size] = data;
	stack->size++;
}
//返回栈顶元素
void* Top_SeqStack(SeqStack* stack)
{
	if (stack == NULL)
	{
		return NULL;
	}

	if (stack->size == 0)
	{
		return NULL;
	}

	return stack->data[stack->size - 1];
}
//出栈
void Pop_SeqStack(SeqStack* stack)
{
	if (stack == NULL)
	{
		return;
	}

	if (stack->size == 0)
	{
		return;
	}

	stack->data[stack->size - 1] = NULL;
	stack->size--;
}

//判断是否为空
int IsEmpty(SeqStack* stack)
{
	if (stack == NULL)
	{
		return -1;
	}

	if(stack->size == 0)
	{
		return SEQSTACK_TRUE;
	}

	return SEQSTACK_FALSE;
}

//返回栈中元素的个数
int Size_SeqStack(SeqStack* stack)
{
	return stack->size;
}

//清空栈
void Clear_SeqStack(SeqStack* stack)
{
	if(stack == NULL)
	{
		return;
	}

	for (int i = 0; i < stack->size; i++)
	{
		stack->data[i] = NULL;
	}

	stack->size = 0;
}

//销毁
void FreeSpace_SeqStack(SeqStack* stack)
{
	if (stack == NULL)
	{
		return;
	}

	free(stack);
}

main.c

#include "SeqStack.h"

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



int main()
{
	//创建栈
	SeqStack* stack = Init_SeqStack();

	//创建数据
	Person p1 = { "aaa", 10 };
	Person p2 = { "bbb", 20 };
	Person p3 = { "ccc", 30 };
	Person p4 = { "ddd", 40 };
	Person p5 = { "eee", 50 };

	//入栈
	Push_SeqStack(stack, &p1);
	Push_SeqStack(stack, &p2);
	Push_SeqStack(stack, &p3);
	Push_SeqStack(stack, &p4);
	Push_SeqStack(stack, &p5);

	//输出
	while (!IsEmpty(stack))
	{
		Person * person = (Person *) Top_SeqStack(stack);
		printf("%s->%d\n", person->name, person->age);

		Pop_SeqStack(stack);
	}

	FreeSpace_SeqStack(stack);
	return 0;
}

在这里插入图片描述

栈的链式存储

 采用链式存储的栈称为链栈，链栈的优点是便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。通常采用单链表实现，并规定所有操作都是在单链表的表头进行的。这里规定链栈没有头节点，Lhead指向栈顶元素，如下图所示。
在这里插入图片描述

实现

LinkStack.h

#pragma once
#ifndef LINKSTACK_H
#define LINKSTACK_H

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

//链式栈的结点
typedef struct LINKNODE {
	struct LINKNODE* next;
}LinkNode;
//链式栈
typedef struct LINKSTACK {
	LinkNode head;
	int size;
}LinkStack;

//初始化函数
LinkStack* Init_LinkStack();
//入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data);
//出栈
void Pop_LinkStack(LinkStack* stack);
//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack);
//返回栈元素的个数
int Size_LinkStack(LinkStack* stack);
//清空栈
void clear_LinkStack(LinkStack* stack);
//销毁栈
void FreeSpace_LinkStack(LinkStack* stack);

#endif // !LINKSTACK_H

LinkStack.c

#include "LinkStack.h"

//初始化函数
LinkStack* Init_LinkStack()
{
	LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
	stack->head.next = NULL;
	stack->size = 0;

	return stack;
}

//入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data)
{
	if (!stack || !data)
	{
		return;
	}

	data->next = stack->head.next;
	stack->head.next = data;
	stack->size++;
}

//出栈
void Pop_LinkStack(LinkStack* stack)
{
	if (!stack)
	{
		return;
	}

	if (stack->size == 0)
	{
		return;
	}

	LinkNode* pCurrent = stack->head.next;
	stack->head.next = pCurrent->next;

	stack->size--;
}
//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack)
{
	if (!stack)
	{
		return NULL;
	}

	if (stack->size == 0)
	{
		return NULL;
	}

	return stack->head.next;
}

//返回栈元素的个数
int Size_LinkStack(LinkStack* stack)
{
	return stack->size;
}

//清空栈
void clear_LinkStack(LinkStack* stack)
{
	if (!stack)
	{
		return;
	}

	if (stack->size == 0)
	{
		return;
	}

	stack->head.next = NULL;
	stack->size = 0;
}

//销毁栈
void FreeSpace_LinkStack(LinkStack* stack)
{
	if (!stack)
	{
		return;
	}

	free(stack);
}

main.c

#include "LinkStack.h"

typedef struct PERSON
{
	LinkNode node;
	char name[64];
	int age;
}Person;

int main()
{
	//创建栈
	LinkStack* stack = Init_LinkStack();
	//创建数据
	Person p1, p2, p3, p4, p5;
	strcpy(p1.name, "aaa");
	strcpy(p2.name, "bbb");
	strcpy(p3.name, "ccc");
	strcpy(p4.name, "ddd");
	strcpy(p5.name, "eee");

	p1.age = 10;
	p2.age = 20;
	p3.age = 30;
	p4.age = 40;
	p5.age = 50;

	//入栈
	Push_LinkStack(stack, (LinkNode*)&p1);
	Push_LinkStack(stack, (LinkNode*)&p2);
	Push_LinkStack(stack, (LinkNode*)&p3);
	Push_LinkStack(stack, (LinkNode*)&p4);
	Push_LinkStack(stack, (LinkNode*)&p5);

	while (Size_LinkStack(stack))
	{
		//取出栈顶元素
		Person* p = (Person*)Top_LinkStack(stack);
		printf("Name:%s Age:%d\n", p->name, p->age);
		//弹出栈顶元素
		Pop_LinkStack(stack);
	}

	FreeSpace_LinkStack(stack);

	return 0;
}
ccloud11
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python实现队列和栈
topsogn的博客
03-12 1214
python实现队列和栈1、list2、collections模块 1、list 队列：insert列表首部插入，pop() 栈：append列表尾部添加，pop() 2、collections模块 调用collections模块中的deque()类 队列：popleft() 栈：pop()
用栈实现队列和用队列实现栈
SmileTimLi的博客
02-23 1765
第一 队列和栈的了解 栈 -- 先进后出(FILO—First-In/Last-Out) 队列 -- 先进先出(FIFO—first in first out) 对应的方法 栈 入栈：s.push(x) 出栈：s.pop() 访问栈顶：s.top() 判断栈空：s.empty() 访问栈中的元素个数：s.size() 队列  入队：q.push(x) 出队：q.pop(...
C语言利用队列和栈实现回文判断
qq_41982200的博客
10-23 9619
回文判断问题描述算法思想函数模块测试数据C语言程序头文件Stack.hStack.hStack.hLqueue.hLqueue.hLqueue.h主文件实验结果 问题描述 回文是指一个字符序列以中间字符为基准两边字符完全相同。要求程序从键盘输入一个字符串，字符串长度小于或等于818181，用于判断回文的不包括字符串的结束标志。 算法思想 把字符串中的字符逐个分别存入队列和堆栈，然后逐个出队列和退栈并比较出队列的元素和退栈的元素是否相等，若全部相等则该字符是回文，否则就不是回文。 函数模块 （1）voidPa
C#队列和栈的使用
pan_junbiao的博客
07-07 1万+
一、队列队列是其元素以先进先出（Firstin,Firstout,FIFO）的方式来处理的集合。先放入队列中的元素会先读取。队列使用System.Collections.Generic命名空间中的泛型类Queue&lt;T&gt;实现。队列的成员Count：Count属性返回队列中元素个数。Enqueue：Enqueue()方法在队列一端添加一个元素。Dequeue：Dequeue()方法在队列的...
栈实现队列(队列实现栈)
weixin_55742319的博客
01-14 3025
数据结构与算法应用(栈与队列互相实现)
使用栈实现队列
weixin_48276298的博客
05-15 1789
题目介绍 力扣232题：https://leetcode-cn.com/problems/implement-queue-using-stacks/ 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）： 实现 MyQueue 类： void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean empty() 如果队列为空，返回 true ；否
【数据结构与算法】用队列实现栈
Welcome home | Jian Liao 's blog
03-21 1817
😼前面我们相继实现了栈和队列，是不是愁没有练手的地方呢？别担心，本章带大家用队列来实现一个栈！😽我们都知道，栈和队列可以看作为兄弟，一个后进先出(LIFO)，一个先进先出(FIFO)，他们虽有不同的性质，但总的来说还是不分家的，因为，我们既可以用队列实现栈，也可以用栈实现队列，而本章就先来带大家来了解如何使用队列来实现栈。💝学会了用队列实现栈，那么下一篇文章就是教大家如何用栈实现队列了。栈和队列还真是有趣呢！❤️‍🔥后续将会持续输出有关数据结构的文章，你们的支持就是我写作的最大动力！
用两个队列实现栈
jiaomubai的博客
10-04 2031
首先，明白了栈和队列的特点之后，就发现用队列来实现栈和用栈来实现队列的思想差不多是一样的。队列的特点是先进先出，栈的特点是先进先出，用队列来实现栈，即使用队列来完成先进后出的操作。 和用栈实现队列一样，我们假设需要操作的数据为A、B、C、D、E。有两个队列queue1和queue2，和用栈实现队列不同的是，此两个队列没有严格的插入和删除之分，栈实现队列时，我们使用主栈来压栈，辅助栈来弹栈。首先我...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
C语言栈和队列的实现
k666499436的博客
05-28 4645
详细讲解栈与队列的定义和特性，用C语言分别实现顺序栈、链栈、顺序(循环)队列、链队列，已经顺序存储与链式存储的区别
C语言使用队列和栈实现自动生成和求解迷宫
10-15
C语言使用队列和栈实现自动生成和求解迷宫
利用队列和栈实现的简单停车管理系统
08-02
利用队列和栈实现的简单停车管理系统， 我们是
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
栈实现队列
01-09
栈实现队列可以通过使用两个栈来实现队列的入队和出队操作。不同的思路可以满足不同的需求，但思路三是最优的，因为它可以最快地实现入队和出队操作。 在实际应用中，栈实现队列可以用于解决一些实际问题，如实现...
如何使用两个栈实现队列Java
08-25
主要介绍了如何使用两个栈实现队列Java,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
数据结构-绪论
pyc68的博客
06-17 791
本篇文章先介绍数据结构的研究内容，然后再介绍如何去理解数据结构，着重介绍表示数据结构关系的逻辑结构和存储结构（物理结构）。
【CS.DS】数据结构 —— 图: 图的相关概念大全
Charlie_Lee_CS的博客
06-21 604
图是一种数据结构，由节点（顶点）和边组成。图可以用来表示各种网络结构，如社交网络、交通网络、计算机网络等。1000.02.CS.DS.5.1-图结构-基本概念-Created: 2024-06-19.Wednesday15:22。
考研系列-数据结构第七章：查找（上）
最新发布
Nelson_hehe的博客
06-23 55
本文是408考研付费专栏系列-数据数据结构查找章节（上半部分），总结了查找的基本概念，总结了数组查找方法包括顺序查找、二分查找和折半查找，还对树形查找中的二叉排序树和平衡二叉树的内容进行汇总。
[C++][数据结构][LRU Cache]详细讲解
SnowK博客
06-21 1357
[C++][数据结构][LRU Cache]详细讲解
C语言实现队列和栈
06-02
C语言中可以使用数组或链表来实现队列和栈。 1. 队列 使用数组实现队列，需要定义一个指向队列头的指针front和一个指向队列尾的指针rear，队列的长度为maxsize。具体实现如下： ``` #define MAXSIZE 100 typedef ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值