顺序队知识总结及代码实现

最新推荐文章于 2024-07-25 17:43:13 发布

是旧辞啊

最新推荐文章于 2024-07-25 17:43:13 发布

阅读量384

点赞数 1

分类专栏：数据结构文章标签：队列数据结构

本文链接：https://blog.csdn.net/m0_63330233/article/details/121047808

版权

数据结构专栏收录该内容

20 篇文章 2 订阅

订阅专栏

顺序队的存储方式

同一般线性表的顺序存储结构完全相同，利用一组地址连续的存储单元依次存放自队头到队尾的数据元素。

顺序队存储的特点

简单、方便、但是容易溢出(数组大小固定)

队空、队满定义

front == rear 是队空的标志

rear == MAXSIZE 是队满的标志。

解决假上溢的方法

1. 将队中元素依次向队头方向移动。
2. 将队空间设想成一个循环的表，即分配给队列的m个存储单元可以循环使用，当rear为MAXSIZE时，若Q.front向量的开始端空着，又可从头使用空着的空间。当front为MAXSIZE时 ,也是一样。

上述两种方法都可以解决假上溢问题，但是经过对比可以看出第一个方法的缺点是浪费时间，每移动一次，队中元素都要移动，所以一般都是选择第二种方法。

顺序队功能函数

bool InitQueue(SqQueue &Q); //1.队的初始化

bool QueueEmpty(SqQueue Q); //2.判断是否为空

int QueueLength(SqQueue Q); //3.求队的长度

bool DestroyQueue(SqQueue &Q); //4.销毁队

void ClearQueue(SqQueue &Q); //5.清空顺序队

bool EnQueue(SqQueue &Q,ElemType e); //6.入队

bool DeQueue(SqQueue &Q,ElemType &e); //7.出队

bool GetHead(SqQueue Q,ElemType &e); //8.得到队头元素

非循环顺序队列代码实现

#include<bits/stdc++.h>
using namespace std;
#define MAXSIZE 100
typedef int ElemType;
typedef struct SqQueue {
	ElemType *base;
	int front;
	int rear;
}SqQueue;

//初始化顺序队 
bool InitQueue(SqQueue &Q) {
	Q.front = Q.rear = 0;
	Q.base = new ElemType[MAXSIZE];
	if(!Q.base)  //存储分配失败 
		exit(-1);
	return true;
}

//判断队列是否为空 
bool QueueEmpty(SqQueue Q) {
	if(Q.front == Q.rear)
		return true;
	return false;
}

//销毁队列
bool DestroyQueue(SqQueue &Q) {
	if(Q.base) {
		delete Q.base;
		Q.front = Q.rear = NULL;
	}
} 

//清空队列
bool ClearQueue(SqQueue &Q) {
	if(Q.base) {
		Q.rear = Q.front;
	}
} 

//求队列长度 
int QueueLength(SqQueue Q) {
	return Q.rear - Q.front;
}

//入队 
bool EnQueue(SqQueue &Q,ElemType e) {
	if(Q.rear == MAXSIZE)
		return false;
	Q.base[Q.rear++] = e;
	return true;
} 

//出队 
bool DeQueue(SqQueue &Q,ElemType &e) {
	if(Q.rear == Q.front)
		return false;
	e = Q.base[Q.front++];
	return true;
} 

//获取队头元素 
bool GetHead(SqQueue Q,ElemType &e) {
	if(Q.rear == Q.front)
		return false;
	e = Q.base[Q.front];
	return true;
} 
 
int main() {
	int n;
	ElemType e;
	SqQueue que;
	InitQueue(que);
	cout << "队列已经初始化" << endl;
	cout << "请输入队列中元素个数:" << endl;
	cin >> n;
	cout << "请依次输入队列中元素:" << endl; 
	for(int i = 0; i < n; i++) {	
		cin >> e;
		EnQueue(que, e); 
	} 
	cout << "此时队列的长度为：" << QueueLength(que) << endl;
	cout << "取出队列中所有元素："; 
	for(int i = 0; i < n; i++) {
		DeQueue(que, e);
		cout << e << " ";
	}
	cout << endl;
	cout << "此时队列的长度为：" << QueueLength(que) << endl;
	cout << "在队列中加入一个元素:" << endl;
	cin >> e;
	EnQueue(que, e);
	cout << "此时队头元素为：" << e << endl;
	GetHead(que, e);
	cout << "此时队列的长度为：" << QueueLength(que) << endl;
	cout << "清空队列" << endl;
	ClearQueue(que);
	cout << "此时队列的长度为：" << QueueLength(que) << endl;
	DestroyQueue(que);
	return 0;
}

循环顺序队列

在上述顺序队中发现，顺序队的空间有时并没有被完全利用，会出现假上溢现象，为了解决假上溢现象就提出使用循环顺序队来防止它的发生。

如下图所示，base[0]接在base[MAXQSIZE -1]之后，若rear+ 1==M,则令rear=0;循环顺序队是循环使用为队列分配的存储空间。

实现方法循环顺序队的方法就是利用模(mod, C语言中: %)运算，因此循环顺序队在进行插入元素、删除元素操作时与顺序队的不同在于要多进行一次模运算:

插入元素:

        Q.base[Q.rear]=x;

        Q.rear=(Q.rear+ 1)% MAXQSIZE;

删除元素:

        x=Q.base[s.front];

        Q.front=(Q.front+ 1)% MAXQSIZE

循环顺序队列解决队满时的判断方法

在上述图中应该就发现了问题所在，就是队空和队满的判断条件都是front == rear，显然这是不行的，于是便有三种解决方法，如下：

1.另外设一个标志以区别队空、队满

2.另设一个变量，记录元素个数

3.少用一个无素空间

通常情况下都是采用第三种方法，因此这里就利用第三种方法来实现循环顺序队，其示意图如下：

此时队空的条件还是front == rear

队满的条件则是(rear + 1) % MAXSIZE == front

循环顺序队列代码实现

#include<bits/stdc++.h>
using namespace std;
#define MAXSIZE 10
typedef int ElemType;
typedef struct SqQueue {
	ElemType *base;
	int front;
	int rear;
}SqQueue;

//初始化循环顺序队 
bool InitQueue(SqQueue &Q) {
	Q.front = Q.rear = 0;
	Q.base = new ElemType[MAXSIZE];
	if(!Q.base)  //存储分配失败 
		exit(-1);
	return true;
}

//判断循环顺序队是否为空 
bool QueueEmpty(SqQueue Q) {
	if(Q.front == Q.rear)
		return true;
	return false;
}

//销毁队列
bool DestroyQueue(SqQueue &Q) {
	if(Q.base)
		delete Q.base;
	Q.base = NULL;
	Q.front = Q.rear = 0;
} 

//清空队列
void ClearQueue(SqQueue &Q) {
	Q.rear = Q.front = 0;
} 

//求队列长度 
int QueueLength(SqQueue Q) {
	return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}

//入队 
bool EnQueue(SqQueue &Q, ElemType e) {
	if((Q.rear + 1) % MAXSIZE == Q.front)
		return false;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXSIZE;
	return true;
} 

//出队 
bool DeQueue(SqQueue &Q, ElemType &e) {
	if(Q.rear == Q.front)
		return false;
	e = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXSIZE;
	return true;
} 

//获取队头元素 
bool GetHead(SqQueue Q, ElemType &e) {
	if(Q.rear == Q.front)
		return false;
	e = Q.base[Q.front];
	return true;
} 
 
int main() {
	int n;
	ElemType e;
	SqQueue que;
	InitQueue(que);
	cout << "队列已经初始化" << endl;
	cout << "请输入队列中元素个数:" << endl;
	cin >> n;
	cout << "请依次输入队列中元素:" << endl; 
	for(int i = 0; i < n; i++) {	
		cin >> e;
		EnQueue(que, e); 
	} 
	cout << "此时队列的长度为：" << QueueLength(que) << endl;
	cout << "取出队列中所有元素："; 
	for(int i = 0; i < n; i++) {
		DeQueue(que, e);
		cout << e << " ";
	}
	cout << endl;
	cout << "此时队列的长度为：" << QueueLength(que) << endl;
	cout << "在队列中加入一个元素:" << endl;
	cin >> e;
	EnQueue(que, e);
	cout << "此时队头元素为：" << e << endl;
	GetHead(que, e);
	cout << "此时队列的长度为：" << QueueLength(que) << endl;
	cout << "清空队列" << endl;
	ClearQueue(que);
	cout << "此时队列的长度为：" << QueueLength(que) << endl;
	DestroyQueue(que);
	return 0;
}

是旧辞啊

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
顺序队知识总结及代码实现

顺序队的存储方式同一般线性表的顺序存储结构完全相同，利用一组地址连续的存储单元依次存放自队头到队尾的数据元素。#include<bits/stdc++.h>using namespace std;#define MAXSIZE 100typedef int ElemType;typedef struct SqQueue { ElemType *base; int front; int rear;}SqQueue;//初始化顺序队 bool InitQueu...
复制链接

扫一扫