数据结构--循环队列、链队

这篇具有很好参考价值的文章主要介绍了数据结构--循环队列、链队。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

基础知识

//循环队列数据结构
typedef struct
{
QElemType data[MaxQSize];//数据域
int front,rear; //队头队尾指针
}SqQueue;

//链队结点数据结构
typedef struct QNode
{
int data;//数据域
struct QNode* next;//指针域

}QNode, * QueuePtr;
typedef struct
{
struct QNode* front, * rear;//rear指针指向队尾 用于入队 front指针指向队头 用于出队
}LinkQueue;

队列是一种常见的数据结构,它遵循==先进先出(FIFO)==的原则。以下是队列的基本操作:
1、入队(Enqueue):将元素添加到队列的末尾。
2、出队(Dequeue):从队列的头部移除一个元素,并返回其值。
3、队列长度(Size):获取队列中元素的个数。
4、队列是否为空(IsEmpty):检查队列是否为空。
5、获取队首元素(Front):获取队列头部的元素值,但不移除该元素。文章来源地址https://www.toymoban.com/news/detail-615149.html

C++ 实现队列的基本操作的示例代码:

#include <iostream>
#include <queue>

int main() {
    std::queue<int> myQueue;

    // 入队
    myQueue.push(10);
    myQueue.push(20);
    myQueue.push(30);

    // 队列长度
    std::cout << "队列长度:" << myQueue.size() << std::endl;

    // 出队
    int frontElement = myQueue.front();
    myQueue.pop();
    std::cout << "出队元素:" << frontElement << std::endl;

    // 获取队首元素
    std::cout << "队首元素:" << myQueue.front() << std::endl;

    // 队列是否为空
    std::cout << "队列是否为空:" << (myQueue.empty() ? "是" : "否") << std::endl;

    return 0;
}

在C语言中,队列的基本操作可以通过结构体和指针来实现。

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

// 定义队列结构体
typedef struct {
    int *array;  // 存储队列元素的数组
    int front;   // 队首索引
    int rear;    // 队尾索引
    int size;    // 队列的容量
} Queue;

// 初始化队列
void initQueue(Queue *queue, int capacity) {
    queue->array = (int*)malloc(capacity * sizeof(int));
    queue->front = 0;
    queue->rear = -1;
    queue->size = 0;
}

// 销毁队列
void destroyQueue(Queue *queue) {
    free(queue->array);
}

// 入队
void enqueue(Queue *queue, int element) {
    queue->rear = (queue->rear + 1) % queue->size;
    queue->array[queue->rear] = element;
    queue->size++;
}

// 出队
int dequeue(Queue *queue) {
    int dequeuedElement = queue->array[queue->front];
    queue->front = (queue->front + 1) % queue->size;
    queue->size--;
    return dequeuedElement;
}

// 获取队列长度
int getSize(Queue *queue) {
    return queue->size;
}

// 检查队列是否为空
int isEmpty(Queue *queue) {
    return queue->size == 0;
}

// 获取队首元素
int getFront(Queue *queue) {
    return queue->array[queue->front];
}

int main() {
    Queue myQueue;
    initQueue(&myQueue, 5);

    // 入队
    enqueue(&myQueue, 10);
    enqueue(&myQueue, 20);
    enqueue(&myQueue, 30);

    // 队列长度
    printf("队列长度:%d\n", getSize(&myQueue));

    // 出队
    int frontElement = dequeue(&myQueue);
    printf("出队元素:%d\n", frontElement);

    // 获取队首元素
    printf("队首元素:%d\n", getFront(&myQueue));

    // 队列是否为空
    printf("队列是否为空:%s\n", isEmpty(&myQueue) ? "是" : "否");

    destroyQueue(&myQueue);
    return 0;
}

循环队列

#define MaxSize 100
typedef struct { int data[MaxSize]; int front, rear; }SqQueue;

//***********************************   基本操作函数  *******************************************

int InitQueue(SqQueue &Q)
{
	Q.front = Q.rear = 0;
	return 1;

}
bool QueueEmpty(SqQueue& Q) {
	if (Q.front != Q.rear)	return true;
	else   return false;
}

//入队:尾部加1;	出队:头部加1
bool EnQueue(SqQueue& Q, int& e) {
	if (Q.front ==Q.rear)	return false;
	e = Q.data[Q.rear];
	Q.rear = (Q.rear + 1) % MaxSize; //指针加1 取模
	return true;
}

bool DeQueue(SqQueue& Q, int &e) {
	if (Q.front == Q.rear)	return false;
	e = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize; //指针加1 取模
	return true;
}

bool GetHead(SqQueue& Q, int &e)
{
	if (Q.front == Q.rear)	return false;//队空 					
	e = Q.data[Q.front];
	return true;
}



//********************************功能实现函数**************************************//

void EnterToQueue(SqQueue& Q)
{
	int n; int e; int flag;
	printf("请输入入队元素个数(>=1):\n");
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		printf("请输入第%d个元素的值:", i + 1);
		scanf("%d", &e);
		flag = EnQueue(Q, e);
		if (flag)printf("%d已入队\n", e);
		else { printf("队已满!!!\n"); break; }
	}
}

void DeleteFromQueue(SqQueue& Q)
{
	int n; int e; int flag;
	printf("请输入出队元素个数(>=1):\n");
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		flag = DeQueue(Q, e);
		if (flag)printf("%d已出队\n", e);
		else { printf("队已空!!!\n"); break; }
	}
}

void GetHeadOfQueue(SqQueue Q)
{
	int e; bool flag;
	flag = GetHead(Q, e);
	if (flag)printf("队头元素为:%d\n", e);
	else printf("队已空!!!\n");
}



void menu() {
	printf("********1.入队          2.出队*********\n");
	printf("********3.取队头元素    4.退出*********\n");
}

int main() {
	SqQueue Q;
	int choice = 0;;
	InitQueue(Q);

	while (1)
	{
		menu();
		printf("请输入菜单序号:\n");
		scanf("%d", &choice);
		if (choice == 4) break;
		switch (choice)
		{
		case 1:EnterToQueue(Q); break;
		case 2:DeleteFromQueue(Q); break;
		case 3:GetHeadOfQueue(Q); break;
		default:printf("输入错误!!!\n");
		}
		system("pause");
		system("cls");
	}

	return 0;
}

链队

#define MaxSize 100

//链队结点数据结构
typedef struct QNode
{
	int data;//数据域
	struct QNode* next;//指针域

}QNode, * QueuePtr;
typedef struct
{
	struct QNode* front, * rear;//rear指针指向队尾 用于入队 front指针指向队头 用于出队
}LinkQueue;



//***********************************   基本操作函数  *******************************************

int InitQueue(LinkQueue &Q)
{
	Q.front = Q.rear = new QNode;
	Q.front->next = NULL;
	return 1;

}


int EnQueue(LinkQueue& Q, int& e) {
	QNode* p;
	p = new QNode;//生成新节点
	p->data = e;    //赋值
	p->next = NULL;
	Q.rear->next = p;//加入队尾
	Q.rear = p;      //尾指针后移
	return 1;
}

bool DeQueue(LinkQueue &Q, int &e) {
	QueuePtr p;
	if (Q.front == Q.rear)return false;//队空
	e = Q.front->next->data;           //e返回值 之前写的Q.front->data 炸了,头结点没数据的,一定要注意头结点
	p = Q.front->next;                //保留,一会儿释放空间
	Q.front->next = p->next;          //出队,注意Q.front->next 不是Q.front 还有头结点
	if (Q.rear == p)Q.rear = Q.front;    //最后一个元素出队,rear指向头结点
	free(p);
	return true;
}

//取队顶函数 用e返回
bool GetHead(LinkQueue &Q, int &e)
{
	if (Q.front == Q.rear)	return false;//队空 					
	e = Q.front->next->data;
	return true;
}



//********************************功能实现函数**************************************//

void EnterToQueue(LinkQueue& Q)
{
	int n; int e; int flag;
	printf("请输入入队元素个数(>=1):\n");
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		printf("请输入第%d个元素的值:", i + 1);
		scanf("%d", &e);
		flag = EnQueue(Q, e);
		if (flag)printf("%d已入队\n", e);
	}
}

void DeleteFromQueue(LinkQueue& Q)
{
	int n; int e; int flag;
	printf("请输入出队元素个数(>=1):\n");
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		flag = DeQueue(Q, e);
		if (flag)printf("%d已出队\n", e);
		else { printf("队已空!!!\n"); break; }
	}
}

void GetHeadOfQueue(LinkQueue Q)
{
	int e; bool flag;
	flag = GetHead(Q, e);
	if (flag)printf("队头元素为:%d\n", e);
	else printf("队已空!!!\n");
}



void menu() {
	printf("********1.入队          2.出队*********\n");
	printf("********3.取队头元素    4.退出*********\n");
}

int main() {
	LinkQueue Q;
	int choice = 0;;
	InitQueue(Q);

	while (1)
	{
		menu();
		printf("请输入菜单序号:\n");
		scanf("%d", &choice);
		if (choice == 4) break;
		switch (choice)
		{
		case 1:EnterToQueue(Q); break;
		case 2:DeleteFromQueue(Q); break;
		case 3:GetHeadOfQueue(Q); break;
		default:printf("输入错误!!!\n");
		}
		system("pause");
		system("cls");
	}

	return 0;
}

到了这里,关于数据结构--循环队列、链队的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包赞助服务器费用

相关文章

  • 数据结构(C语言实现)——栈和队列的介绍及基本操作的实现(动态顺序栈+链队)

    今天我们来学习另外两个线性结构——栈和队列,栈和队列是操作受限的线性表,因此,可称为限定性的数据结构。 栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶,另一端称为栈底。栈中的数据元素遵守

    2023年04月19日
    浏览(12)
  • 【数据结构与算法】用队列实现栈&&用栈实现队列&&设计循环队列

    【数据结构与算法】用队列实现栈&&用栈实现队列&&设计循环队列

    🌠 作者:@ 阿亮joy. 🎆 专栏:《数据结构与算法要啸着学》 🎇 座右铭:每个优秀的人都有一段沉默的时光,那段时光是付出了很多努力却得不到结果的日子,我们把它叫做扎根 请你仅使用两个队列实现一个后入先出(LIFO)的栈,并支持普通栈的全部四种操作(push、top、

    2024年01月20日
    浏览(12)
  • 【C++】【数据结构】循环队列的基本操作(初始化、入队、出队、取队头元素、遍历输出队列、求队列长度)顺序队列的算法实现【附全代码】

    【C++】【数据结构】循环队列的基本操作(初始化、入队、出队、取队头元素、遍历输出队列、求队列长度)顺序队列的算法实现【附全代码】

    使用c++完成数据结构循环队列的基本操作,包括(初始化、入队、出队、取队头元素、遍历输出队列、求队列长度等),可直接编译运行。 队列 又称为 “先进先出” (FIFO)线性表。限定插入操作只能在队尾进行,而删除操作只能在队首进行。 循环队列 ——采用 顺序存储结构

    2023年04月16日
    浏览(14)
  • 【数据结构与算法分析】使用C语言实现队列的两种(带头结点与不带头结点)链式存储,并且给出一种循环队列的设计思想

    【数据结构与算法分析】使用C语言实现队列的两种(带头结点与不带头结点)链式存储,并且给出一种循环队列的设计思想

      当我们编写程序时,经常需要处理各种数据结构。队列是一种常见的数据结构,它有着广泛的应用场景。队列的基本操作包括入队和出队,应用于模拟等待队列、消息队列、计算机缓存等场合。   在实际编程中,我们可以用不同的数据结构来实现队列。本文主要介绍了

    2024年02月08日
    浏览(205)
  • 数据结构--队列与循环队列

    数据结构--队列与循环队列

            队列是什么,先联想一下队,排队先来的人排前面先出,后来的人排后面后出;队列的性质也一样,先进队列的数据先出,后进队列的后出;就像图一的样子:  图1         如图1,1号元素是最先进的,开始出队时,那么他就是最先出的,然后12进队,就应该排在最

    2024年02月10日
    浏览(9)
  • 数据结构—循环队列(环形队列)

    数据结构—循环队列(环形队列)

    循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且 队尾被连接在队首之后以形成一个循环 。它也被称为“ 环形缓冲器 ”。 循环队列的一个好处是可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素

    2024年02月11日
    浏览(8)
  • 数据结构:循环队列的实现(leetcode622.设计循环队列)

    数据结构:循环队列的实现(leetcode622.设计循环队列)

      目录 一.循环队列简单介绍 二.用静态数组实现循环队列 1.数组循环队列结构设计 2.数组循环队列的堆区内存申请接口  3.数据出队和入队的接口实现 4.其他操作接口 5.数组循环队列的实现代码总览  三.静态单向循环链表实现循环队列  1.链表循环队列的结构设计 2.创建静态

    2024年02月03日
    浏览(9)
  • 数据结构——循环队列详解

    数据结构——循环队列详解

    目录 一、循环队列的定义 二、 循环队列的基本操作 三、循环队列的实现  1、循环队列的定义 2、循环队列的初始化  3、循环队列出队  4、循环队列入队  5、队列判空 6、 队列判满 7、取队头元素 8、输出队列  9、求队列长度  四、完整代码  五、小结  六、参考文献 一、

    2024年02月04日
    浏览(10)
  • 【数据结构】循环队列

    【数据结构】循环队列

    🚀 作者简介:一名在后端领域学习,并渴望能够学有所成的追梦人。 🐌 个人主页:蜗牛牛啊 🔥 系列专栏:🛹数据结构、🛴C++ 📕 学习格言:博观而约取,厚积而薄发 🌹 欢迎进来的小伙伴,如果小伙伴们在学习的过程中,发现有需要纠正的地方,烦请指正,希望能够与

    2024年02月12日
    浏览(13)
  • 数据结构——循环队列的实现

    数据结构——循环队列的实现

    hello hello~ ,这里是大耳朵土土垚~💖💖 ,欢迎大家点赞🥳🥳关注💥💥收藏🌹🌹🌹 💥 个人主页:大耳朵土土垚的博客 💥 所属专栏:数据结构学习笔记 💥对于数据结构顺序表、链表、堆有疑问的都可以在上面数据结构的专栏进行学习哦~ 有问题可以写在评论区或者私信

    2024年03月24日
    浏览(9)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包