队列的链式和顺序存储及其相关操作

已于 2022-05-15 23:27:12 修改
阅读量445 收藏 3
点赞数 1
文章标签： c++ 数据结构 链表
于 2022-05-15 23:09:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63010894/article/details/124789354
版权

目录

一、链式存储

1.结构体的定义

typedef struct Queue_Node
{
	DataType data;
	Queue_Node* next;
}*QueueNodePtr;

typedef struct Link_Queue
{
	QueueNodePtr front;
	QueueNodePtr rear;
}*LinkQueuePtr;

DataType是操作者自己定义的数据类型。

2.初始化

LinkQueuePtr InitQueue()
{
	LinkQueuePtr resultPtr = new struct Link_Queue;

	QueueNodePtr headerPtr = new struct Queue_Node;

	headerPtr->next = NULL;

	resultPtr->front = resultPtr->rear = headerPtr;

	return resultPtr;
}

初始化构建队列数据结构
在这里插入图片描述

3.入队

void EnterQueue(LinkQueuePtr paraQueuePtr, int paraElement) {
	//Step 1. Create a new node
	QueueNodePtr tempNodePtr = new struct Queue_Node;

	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;

	//Step 2. Link to the existing rear
	paraQueuePtr->rear->next = tempNodePtr;

	//Step 3. It is the new rear
	paraQueuePtr->rear = tempNodePtr;
}

在这里插入图片描述

4.出队

DataType DeleteQueue(LinkQueuePtr paraQueuePtr) {
	int resultValue;
	QueueNodePtr tempNodePtr = NULL;

	//Step 1. Is the queue empty?
	if (paraQueuePtr->front == paraQueuePtr->rear) 
	{
		cout << "The queue is empty." << endl;
		return -1;
	}

	//Step 2. Change the queue.
	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;

	//Step 2.1 Deal with the case of only one node
	if (paraQueuePtr->rear == tempNodePtr) 
		paraQueuePtr->rear = paraQueuePtr->front;

	//Step 3. Free space.
	 free(tempNodePtr);

	//Step 4. Return.
	return resultValue;
}

在这里插入图片描述

5.打印元素

void outputLinkQueue(LinkQueuePtr paraQueuePtr) {
	QueueNodePtr tempPtr = paraQueuePtr->front->next;

	while (tempPtr != NULL) 
	{
		printf("%d ", tempPtr->data);
		tempPtr = tempPtr->next;
	}
	cout << endl;
}

6.完整代码

#include <stdio.h>
#include <iostream>

using namespace std;

typedef int DataType; //队列中元素类

typedef struct Queue_Node
{
	DataType data;
	Queue_Node* next;
}*QueueNodePtr;

typedef struct Link_Queue
{
	QueueNodePtr front;
	QueueNodePtr rear;
}*LinkQueuePtr;

LinkQueuePtr InitQueue()
{
	LinkQueuePtr resultPtr = new struct Link_Queue;

	QueueNodePtr headerPtr = new struct Queue_Node;

	headerPtr->next = NULL;

	resultPtr->front = resultPtr->rear = headerPtr;

	return resultPtr;
}

void EnterQueue(LinkQueuePtr paraQueuePtr, int paraElement) {
	//Step 1. Create a new node
	QueueNodePtr tempNodePtr = new struct Queue_Node;

	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;

	//Step 2. Link to the existing rear
	paraQueuePtr->rear->next = tempNodePtr;

	//Step 3. It is the new rear
	paraQueuePtr->rear = tempNodePtr;
}

DataType DeleteQueue(LinkQueuePtr paraQueuePtr) {
	int resultValue;
	QueueNodePtr tempNodePtr = NULL;

	//Step 1. Is the queue empty?
	if (paraQueuePtr->front == paraQueuePtr->rear) 
	{
		cout << "The queue is empty." << endl;
		return -1;
	}

	//Step 2. Change the queue.
	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;

	//Step 2.1 Deal with the case of only one node
	if (paraQueuePtr->rear == tempNodePtr) 
		paraQueuePtr->rear = paraQueuePtr->front;

	//Step 3. Free space.
	 free(tempNodePtr);

	//Step 4. Return.
	return resultValue;
}

void outputLinkQueue(LinkQueuePtr paraQueuePtr) {
	QueueNodePtr tempPtr = paraQueuePtr->front->next;

	while (tempPtr != NULL) 
	{
		printf("%d ", tempPtr->data);
		tempPtr = tempPtr->next;
	}
	cout << endl;
}

void testLinkQueue() {
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = InitQueue();
	EnterQueue(tempQueuePtr, 10);
	EnterQueue(tempQueuePtr, 30);
	EnterQueue(tempQueuePtr, 50);

	outputLinkQueue(tempQueuePtr);

	cout << endl;

	printf("dequeue gets %d\r\n", DeleteQueue(tempQueuePtr));
	printf("dequeue gets %d\r\n", DeleteQueue(tempQueuePtr));
	printf("dequeue gets %d\r\n", DeleteQueue(tempQueuePtr));
	printf("dequeue gets %d\r\n", DeleteQueue(tempQueuePtr));

	outputLinkQueue(tempQueuePtr);
}

int main()
{
	testLinkQueue();

	system("pause");
	return 0;
}

7.运行结果

在这里插入图片描述

二、顺序存储

1.结构体的定义

typedef struct Queue
{
	int queue[MaxSize];
	int front;  //队头指针  
	int rear;  //队尾指针 
}SeQueue;

这里没有采用地址指针，采用下标指针更好理解一点。

2.初始化

//初始化队列 
void InitQueue(SeQueue *SQ)
{
	if(!SQ)
		return ;
		
	SQ->front = SQ->rear = 0;//队头和队尾“指针 ”同时置为0 
}

在这里插入图片描述

3.判断队列是否已满

//判断队列是否已满
int IsFull(SeQueue *SQ)
{
	if(!SQ)
		return 0;
		
	if(SQ->rear == MaxSize)
		return 1;
	else
		return 0;
}

在这里插入图片描述

4.判断队列是否为空

//判断队列是否为空
int IsEmpty(SeQueue *SQ)
{
	if(!SQ)
		return 0;
	
	if(SQ->front == SQ->rear)
		return 1;
	else 
		return 0;
}

在这里插入图片描述

5.入队

//入队，插入元素
int EnterQueue(SeQueue *SQ,int data)
{
	if(!SQ)
		return 0;
		
	if(IsFull(SQ))
	{
		cout<<"无法插入:"<<data<<",队列已满!"<<endl;
		return 0; 
	}else
	{
		SQ->queue[SQ->rear] = data;//能且只能在队尾插入data
		SQ->rear++;//队尾指针向后移动一位 
	}
	return 1;
}

在这里插入图片描述

6.1 出队：(法一）

//出队法一：将队列的队头元素data出队，后面元素向前移动
int OutOfQueue(SeQueue *SQ,int * data,int num)
{
	if(!SQ||IsEmpty(SQ))
	{
		cout<<"队列为空!"<<endl;
		return 0; 
	}
	
	if(!data)
	{
		return 0;
	}
	
	*data = SQ->queue[SQ->front];
	
	int i=SQ->front+1;
	
	//后面元素向前覆盖
	for(i=SQ->front;i<SQ->rear-1;i++)
	{
		SQ->queue[i] = SQ->queue[i+1];
	} 
	//出队一个，队尾指针向前移一个 
	SQ->rear--;
	
	return 1;
}

在这里插入图片描述
法一是先整体移动元素，然后尾指针-1.

6.2 出队：(法二)

//出队法二: 元素不移动，头指针移动。但是队列长度会随之变小
int OutOfQueue2(SeQueue *SQ,int *data,)
{
	if(!SQ||IsEmpty(SQ))
	{
		cout<<"队列为空!"<<endl;
		return 0; 
	}
	
	if(SQ->front>=MaxSize)
	{
		cout<<"队列已到尽头!"<<endl;
		return 0;
	} 
	
	*data = SQ->queue[SQ->front];//出队元素的值 
	SQ->front = (SQ->front)+1;//队首指针后移一位 
	
	return 1;
}

1.参数采用 int *data,其实和 int &data是一个意思，都是为了把删除的元素带出去。
2.采用头指针后移的方式，可能会造成“假溢出”。
在这里插入图片描述

7.获取队首元素

//获取队首元素，但不出队
int GetHead(SeQueue *SQ,int *data)
{
	if(!SQ||IsEmpty(SQ))
	{
		cout<<"队列为空!"<<endl;
		return 0; 
	}
	return *data = SQ->queue[SQ->front]; 
}

8.获取队长

//获取队列中元素的个数 
int GetLength(SeQueue *SQ) 
{
	if(!SQ)
		return 0;
		
	return SQ->rear - SQ->front;
}

9.打印

//打印队列中的各元素
void PrintQueue(SeQueue *SQ)
{
	if(!SQ)
		return ;
	
	int i = SQ->front;
	while(i<SQ->rear)
	{
		cout<<setw(4)<<SQ->queue[i++];
	}
	
}

setw(n) n 表示宽度

10.清空队列

//清空队列
int CleanQueue(SeQueue *SQ) 
{
	if(!SQ)
		return 0;
	
	SQ->front = SQ->rear = 0;//头指针，尾指针 同时指向队首 
	return 1;
}

11.完整代码

#include <iostream>
#include <stdio.h>
//#include <assert.h>

#include <iomanip>

using namespace std;

#define MaxSize 5//队列的最大容量 


typedef struct Queue
{
	int queue[MaxSize];
	int front;  //队头指针  （不是真正意义上的指针 ） 
	int rear;  //队尾指针 
}SeQueue;

//初始化队列 
void InitQueue(SeQueue *SQ)
{
	if(!SQ)
		return ;
		
	SQ->front = SQ->rear = 0;//队头和队尾“指针 ”同时置为0 
}

//判断队列是否已满
int IsFull(SeQueue *SQ)
{
	if(!SQ)
		return 0;
		
	if(SQ->rear == MaxSize)
		return 1;
	else
		return 0;
} 

//判断队列是否为空
int IsEmpty(SeQueue *SQ)
{
	if(!SQ)
		return 0;
	
	if(SQ->front == SQ->rear)
		return 1;
	else 
		return 0;
} 

//入队，插入元素
int EnterQueue(SeQueue *SQ,int data)
{
	if(!SQ)
		return 0;
		
	if(IsFull(SQ))
	{
		cout<<"无法插入:"<<data<<",队列已满!"<<endl;
		return 0; 
	}else
	{
		SQ->queue[SQ->rear] = data;//能且只能在队尾插入data
		SQ->rear++;//队尾指针向后移动一位 
	}
	return 1;
} 

//出队法一：将队列的队头元素data出队，后面元素向前移动
int OutOfQueue(SeQueue *SQ,int * data,int num)
{
	if(!SQ||IsEmpty(SQ))
	{
		cout<<"队列为空!"<<endl;
		return 0; 
	}
	
	if(!data)
	{
		return 0;
	}
	
	*data = SQ->queue[SQ->front];
	
	int i=SQ->front+1;
	
	//后面元素向前移动
	 
	/*法一*/ 
//	for(i=SQ->front+1;i<SQ->rear;i++)
//	{
//		SQ->queue[i-1] = SQ->queue[i];
//	}
	
	/*法二*/ 
	for(i=SQ->front;i<SQ->rear-1;i++)
	{
		SQ->queue[i] = SQ->queue[i+1];
	} 
	//出队一个，队尾指针向前移一个 
	SQ->rear--;
	
	return 1;
} 

//出队法二: 元素不移动，头指针移动。但是队列长度会随之变小
int OutOfQueue2(SeQueue *SQ,int * data,int num)
{
	if(!SQ||IsEmpty(SQ))
	{
		cout<<"队列为空!"<<endl;
		return 0; 
	}
	
	if(SQ->front>=MaxSize)
	{
		cout<<"队列已到尽头!"<<endl;
		return 0;
	} 
	
	*data = SQ->queue[SQ->front];//出队元素的值 
	SQ->front = (SQ->front)+1;//队首指针后移一位 
	
	return 1;
}  

//获取队首元素，但不出队
int GetHead(SeQueue *SQ,int *data)
{
	if(!SQ||IsEmpty(SQ))
	{
		cout<<"队列为空!"<<endl;
		return 0; 
	}
	return *data = SQ->queue[SQ->front]; 
} 

//打印队列中的各元素
void PrintQueue(SeQueue *SQ)
{
	if(!SQ)
		return ;
	
	int i = SQ->front;
	while(i<SQ->rear)
	{
		cout<<setw(4)<<SQ->queue[i++];
	}
	
} 

//清空队列
int CleanQueue(SeQueue *SQ) 
{
	if(!SQ)
		return 0;
	
	SQ->front = SQ->rear = 0;//头指针，尾指针 同时指向队首 
	return 1;
}

//获取队列中元素的个数 
int GetLength(SeQueue *SQ) 
{
	if(!SQ)
		return 0;
		
	return SQ->rear - SQ->front;
}

int main()
{
	SeQueue *SQ = new SeQueue;
	
	int /*DataType*/data,i;
	
	
	//初始化队列
	 InitQueue(SQ);
	 
	//入队
	int num;
	cout<<"请输入元素的个数:";
	cin>>num;
	for(i=0;i<num;i++)
	{
		EnterQueue(SQ,i);
	} 
	
	//打印队列中的元素
	cout<<endl<<"队列的元素:";
	PrintQueue(SQ);
	printf("\n队列中的元素个数为:%d\n",GetLength(SQ));
	cout<<endl;
	
	//出队 
	cout<<"请输入出队的次数:";
	cin>>num;
	 
	if(num>MaxSize)
		cout<<endl<<"出队次数过多!"<<endl<<endl;
	 for(i=0;i<num;i++)
	 {
	 	if(OutOfQueue2(SQ,&data,num))
	 	{
	 		cout<<"出队的元素是:"<<data<<endl;
	 		printf("队列中的元素个数为:%d\n",GetLength(SQ));
	 		cout<<"队列:"; 
	 		PrintQueue(SQ);
	 		cout<<endl<<endl;
	 	}else
	 		cout<<"出队失败!!!"<<endl;
	 }
	 
	 //清空队列
	 if(CleanQueue(SQ))
	 	cout<<"销毁成功!";
	return 0;
}

12.测试结果

在这里插入图片描述
在这里插入图片描述

三、总结

1.队列也是一个经典的数据结构，关键是抓住先进先出，后进后出的方式。
2.出队时给出了两种方法，法二看上去，每次出队都会使得队容量减少，但是在某些情况下这也是很有用的特性。

C++New不出对象
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++循环队列与链队列基本操作的实现
qq_60462402的博客
04-23 3238
队列定义 队列，一种特殊的线性表，乍一看总觉得和栈有那么千丝万缕的联系。事实上，队列的确与栈非常类似，但它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 循环队列–队列的顺序表示与实现 就是与顺序表对应的队列类型，使用一组连续的存储单元依次存放队列从头到尾的元素，同时使用两个整型变量：front（头指针）与rear（尾指针）分别指示队首元素和队尾元素。 循环队列存储结构表示 typ
队列的链表实现方式（C++版）
weixin_42295110的博客
07-06 1341
队列基于链表有两种实现方式:一种是带头结点的实现方式，一种是不带头结点的实现方式。 带头结点的实现方式： 基础代码: #include<stdio.h> #include<stdlib.h> #define ElemType int #define null NULL typedef struct LNode{ //链表结点 ElemType data; struct LNode *next; }LNode; typedef struct QNod
C++实现队列操作(顺序存储和链式存储)
weixin_45883188的博客
12-16 1172
1、任务描述：编写函数，采用链式存储和顺序存储实现队列的初始化、入队、出队操作 2、亮点： ①对于顺序操作增添了函数IsFull()，用来判断队列有没有满，如果满了就重新分配空间 ②由于存在分配在堆上的资源，实现了析构函数 3、运行情况： 4、源代码: #include <iostream> #define QueueElemType int using namespace std; class Queue { private: QueueElemType* Q; int
【C语言实现链式队列】 队列其实真的很简单
m0_46539322的博客
04-08 1515
写在前面： 本系列文章是本人在复习《数据结构》的过程中整理的学习笔记，内容比较简短，形式比较单一。目的不在于获得多少阅读、点赞和收藏，只为记录本人的学习过程。 若有幸被您看到，希望能对您有所帮助，若您发现本文中有出错的地方，望不吝赐教，我定会虚心改进。希望看到此篇文章的您，前进路上不迷茫，未来一片光明。 目录 一、队列的基本概念 1、定义 2、重要术语 3.链式队列 二、链式队列的表示 三、链式队列的基本操作 1.链式队列的创建和初始化 2.判断队列是否为空 3.链式队列的...
栈和队列的操作四——队列的链式存储
m0_72619231的博客
04-23 207
😄，先看一下带头结点的链队列的图形：
顺序存储和链式存储的泛型队列_C语言项目
04-12
本项目专注于实现顺序存储和链式存储的泛型队列，使用C语言作为编程工具，旨在提供灵活且高效的操作接口。下面我们将深入探讨相关知识点。 首先，队列是一种先进先出（First In First Out, FIFO）的数据结构，它的...
队列顺序存储&链式存储.rar
04-12
本资源“队列顺序存储&链式存储.rar”提供了浙江大学在中国大学MOOC上《数据结构》课程中关于队列实现的源代码，主要包含两种存储方式：顺序存储和链式存储。 队列是一种先进先出（First In First Out, FIFO）的...
队列的动态链式存储实现代码分享
09-04
链式存储的队列相比于顺序存储（如数组）有其优势，比如可以灵活地增加或减少存储空间，而无需预先确定队列的大小。此外，由于链表节点的插入和删除操作通常比数组快，因此在处理大量数据时，链式队列的效率可能更高...
第三章 栈和队列 顺序存储结构和链式存储结构
04-20
本章将深入探讨两种重要的数据结构——栈和队列，以及它们的两种常见存储方式：顺序存储结构和链式存储结构。 栈（Stack）被称为“后进先出”（Last In, First Out，简称LIFO）的数据结构。栈的操作主要围绕两个...
数据结构：队列（链式存储、顺序存储）
12-07
在C语言中实现队列，我们通常会用到两种存储方式：链式存储和顺序存储。下面我们将详细介绍这两种实现方法，并讨论如何实现上述提到的功能。 1. **创建队列** 创建队列通常涉及分配内存来存储元素。在链式存储中，...
队列的链表存储结构及实现(建立，入队一个元素，出队一个元素)
04-10
队列的链表存储结构及实现: 1 建立链表队列 2 入队一个元素 3 出队一个元素 4 结束程序运行
队列的顺序存储与链式存储
qq_43666632的博客
09-21 1010
队列的顺序存储与链式存储
队列的链式存储和顺序存储
weixin_30486037的博客
11-29 184
1、队列的链式存储： 思路： （1）建立两个结构体，一存储数据及下一个节点的信息，另一个存储链表的表头和表尾指针。 （2）出队列时一定要注意如果只剩下最后一个节点，要提前让Q->Top=Q->Rear，因为如果tp被删除后，就不能再去调用它的next， 最后就找不到结果了。 #include<stdio.h> #include<stdlib.h&g...
循环顺序队列（初始化、入队、出队、判空）
tkp2014的专栏
07-05 2350
采用循环顺序方式存储队列，测试用例为：将0~9入队，然后打印输出，代码如下： #define MAXQSIZE 100 typedef struct { QElemType data[MAXQSIZE]; int front,rear; }SqQueue; /* 初始化队列 */ void InitiQueue(SqQueue &Q) { Q.front = Q.rear = 0;
C语言使用链表队列实现初始化，出队列，入队列，取队头，遍历
Bo_Sir的博客
11-05 1690
C语言使用链表队列实现初始化，出队列，入队列，取队头，遍历 1.C语言使用链表队列实现初始化，出队列，入队列，取队头，遍历 #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef int DataType; typedef struct Node{ DataType data; struct Node *next; }Nod
数据结构(C语言版)严蔚敏-＞队列的顺序存储(循环队列)和链式存储
坚持不懈的大白的博客
07-07 1326
主要讲述队列的顺序存储和链式存储，其中包括循环队列。
队列概述及存储结构（顺序存储，链式存储，循环队列）代码实现
weixin_43800761的博客
07-13 4939
一、队列的基本概念 1.1 队列的定义   队列(Queue) 简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队。删除元素称为出队或离队。这和我们日常生活中的排队是一致的，最早排队的也是最早离队的，其操 作的特性是先进先出(First In First Out, FIFO)，如： 队头(Front)： 允许删除的一-端，又称队首。 队尾(Rear)。： 允许插入的一-端。 空队列： 不含任何元素的空表。 1.2 队列常见的基本操作 Init
【队列】队列的链式存储结构
恒治学
10-30 100
【队列】队列的链式存储结构 代码 #include <iostream> #include <cstdio> using namespace std; #define OK 1 #define ERROR 0 typedef int status; typedef int QElemType; typedef struct QNode{ QElemType data...
顺序存储的循环队列和链式存储的循环队列的区别
最新发布
05-28
顺序存储的循环队列和链式存储的循环队列都是实现循环队列的方式，它们的主要区别在于存储方式和实现方式上。 顺序存储的循环队列使用数组来实现，队头和队尾指针指向数组中的元素。在入队操作时，队尾指针向后移动...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值