【循环顺序队的实现】

于 2024-08-29 18:29:55 发布
阅读量535 收藏 10
点赞数 23
分类专栏： 数据结构 文章标签： 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82676816/article/details/141573594
版权

1.队列的逻辑结构 与 抽象数据类型定义

  • 先进先出的线性表
    在这里插入图片描述
    在顺序队列中，我们使用头指针front指向队首元素；用尾指针rear指向队尾元素的下一个位置（当然这里的指针是用下标模拟出来的）
    同时顺序队列中的元素当然是用数组来存储的

  • 抽象数据类型如下：
    在这里插入图片描述
    注意这里的传参，本篇使用指针传参，与图中c++的引用有所区别

2.一般顺序队列的模拟操作

  • 初始时，头尾指针均指向下标为0的位置
  • 始终遵循先进先出原则；队头出队，队尾入队
    在这里插入图片描述

3.一般顺序队所面临的假上溢问题：（问题一）

设数组大小为MAXQSIZE
当尾指针rear==MAXQSIZE时 就会出现溢出现象，而这种溢出又分为两种情况

  • 1.真溢出：
    即数组的所有空间都存在元素

特征为：
（1）头指针 front = 0
（2）尾指针 rear = MAXQSIZE

在这里插入图片描述

  • 2.假溢出
    即数组中还存在空闲空间，但尾指针已经越界

特征为：
（1）头指针 front != 0
（2）尾指针 rear = MAXQSIZE

在这里插入图片描述
而为了避免这种假上溢问题，我们就引入了循环队列来解决

4.循环队列解决假上溢问题

4.1将队中元素依次向队头方向移动

但是这样做有一个显著的缺点，即浪费时间；每移动一次，队中元素都要移动。所以并不推荐

4.2循环队列解决假上溢问题

将队空间设想成一个循环的表，即分配给队列的m个存储单元可以循环使用，当rear为maxqsize时，若数组的开始端空着，又可从头使用空着的空间；当front为maxqsize时，同理。

设数组名为data, 则核心思路为：

  • data[0]接在data[MAXQSIZE-1]之后
  • 即当rear+1==MAXQSIZE时，令rear=0;

要想实现上述顺序的循环操作，就需要一个重要的运算方法，即模运算
在这里插入图片描述

  • 队尾插入元素时:
Q->data[Q->rear]=e;//将元素插入到当前尾指针指向的空间（即队尾元素的后一个位置）
Q->rear=(Q->rear+1)% MAXQSIZE;//更新队尾指针指向队尾元素的下一个位置

这里取模的作用就是当rear为maxqsize时，若数组的开始端空着，就可以更新尾指针指向空着的开始端空间（详见第2种插入的情况）

    • 1.一般情况下的插入：

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

在这里插入图片描述

      1. 数组存在空闲的开始端 且 在数组的最后一个空间插入时（此时尾指针需要更新到空闲的数组开始端）：

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

在这里插入图片描述

  • 队头删除元素时:
*e=Q->data[Q->front];//将队头元素传递给变量e
Q->front=(Q->front+1)% MAXQSIZE;//更新队头指针指向当前队头的位置

这里取模的作用就是当front为maxqsize时，若数组的开始端空着，就可以更新头指针指向空着的开始端空间（详见第2种删除的情况）

    • 1.一般情况下的删除：
      在这里插入图片描述
      在这里插入图片描述

在这里插入图片描述

    • 2.数组存在空闲的开始端 且 且此时头指针指向的空间为数组的最后一个空间（此时头指针需要更新到空闲的数组开始端）：
      在这里插入图片描述

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

4.3循环顺序对的 物理结构 与 逻辑结构 的辨析

在解决假上溢问题时，我用一维数组的结构图来分析了具体的操作，而这正是循环顺序对的真实的物理结构，我们仅仅是使用特定的操作使其操作起来如同想象中的头尾相连的环形逻辑结构而已，如下图：

在这里插入图片描述

5.循环队列面临的队空 与 队满判断条件一致的问题 （问题二）

通过取模法我们解决了一般队列的假上溢问题，但是，正常的循环顺序对又给我们带来了新的问题，如下图：
在这里插入图片描述
通过分析我们可以发现，若每个空间都存储一个队列元素，那么不论是队满还是队空，两种情况的判断条件会完全一致

Q->front==Q->rear

6.解决队空 与 队满判断条件一致的方法：

一般有如下三种解决方案，而本篇使用第3种
在这里插入图片描述

6.1循环队列解决队满时判断方法–少用一个元素空间:

在这里插入图片描述
这种方式可以区别队空和队满的判断条件：
判断队空(头尾指针重合时，队空)：

Q->front==Q->rear//头尾指针指针重合时，队空

判断队满（由于少用一个空间，故头尾指针相邻时，队满）：

(Q->rear+1)%MAXQSIZE==Q->front
//见上图：共有两种情况
<1>一般情况，Q->rear+1==Q->front
<2>当尾指针指向数组最后一个空间（rear+1==MAXQSIZE）
头指针指向数组第一个空间时(rear==0),
需要用到取模运算：(Q->rear+1)%MAXQSIZE==Q->front

7.循环顺序队的整队实现（少用一个元素空间）

7.1队列的顺序存储结构

//1.队列的顺序存储结构
typedef struct Queue
{
	QElemType * data;//存储元素的动态数组
	int front;//头指针，若队列不空，指向队列头元素
	int rear;//尾指针，若队列不空，指向队列尾元素的下一个位置
	//注意这里的头尾指针并不是指针变量，而是用下标模拟指针功能的int变量
}Queue;
//Queue：用来定义循环顺序对列

一个循环顺序队的存储结构中包含头指针，指向队列头元素；尾指针，指向队列尾元素的下一个位置；存储元素的动态数组这三个部分

7.2循环顺序队的初始化

注意：这里需要传入结构指针，因为要修改结构体中成员进行动态分配内存

bool InitQueue(Queue *q)
7.2.1算法步骤：

（1）为循环顺序对动态分配空间
（2）初始化头尾指针为0，表示队列为空

//1.循环顺序队的初始化
//注意：这里需要传入结构指针，因为要修改结构体中成员进行动态分配内存
bool InitQueue(Queue *q)
{
	//[1]为循环顺序对动态分配空间
	q->data=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
	//这里由于数组首地址为一个指针，故可以使用q.data来接受mallocmalloc返回的指针

	if (!q->data)
	{
		return false;//内存分配失败
	}

	//[2]初始化头尾指针为0，表示队列为空
	q->front=q->rear=0;
	return true;
}

7.3求循环顺序队的长度

注意：这里不用传入结构指针，因为只计算长度，不改变结构体

int QueueLength(Queue q)
7.3.1算法步骤：

（1）（尾指针 与 头指针作差 再加MAXQSIZE）并取余MAXQSIZE，得到队列长度
//注意这里加MAXQSIZE并取余MAXQSIZE，是防止尾指针在低地址端

7.3.2三种情况下的图解

在这里插入图片描述

//2.求循环顺序队的长度
//注意：这里不用传入结构指针，因为只计算长度，不改变结构体
int QueueLength(Queue q)
{
	//[1]（尾指针 与 头指针作差 再加MAXQSIZE）并取余MAXQSIZE，得到队列长度
	//注意这里加MAXQSIZE并取余MAXQSIZE，是防止尾指针在低地址端
	return (q.rear - q.front + MAXQSIZE) % MAXQSIZE;
}

7.4循环顺序队的入队操作(核心1)

注意：这里需要传入结构指针，因为要修改结构体中成员：传入元素，修改尾指针

bool EnQueue(Queue * q,QElemType e)
7.4.1算法步骤：

（1）判断队列是否已满
（2）进行入队操作
<1>新元素插入到当前尾指针指向的空间（当前队尾元素的下一个位置）
<2>更新尾指针，指向新的队尾结点的下一个位置

//3.循环顺序队的入队操作
//注意：这里需要传入结构指针，因为要修改结构体中成员：传入元素，修改尾指针
bool EnQueue(Queue * q,QElemType e)
{
	
	//[1]判断队列是否已满
	//这里对MAXQSIZE进行取余,是为了应对以下情况
	//尾指针指向数组最后一个空间（rear+1==MAXQSIZE），头指针指向数组第一个空间时(rear==0)
	//因为 MAXQSIZE % MAXQSIZE == 0
	if ((q->rear + 1) % MAXQSIZE == q->front)
	{
		return false;//队满
	}

	//[2]进行入队操作
	//<1>新元素插入到当前尾指针指向的空间（当前队尾元素的下一个位置）
	q->data[q->rear] = e;
	//<2>更新尾指针，指向新的队尾结点的下一个位置
	//这里对MAXQSIZE进行取余,是为了应对以下情况(防止上溢出)
	//尾指针指向数组最后一个空间（rear+1==MAXQSIZE），要更新尾指针指向数组第一个空间时(rear==0)   
	//因为 MAXQSIZE % MAXQSIZE == 0
	q->rear = (q->rear + 1) % MAXQSIZE;

	return true;
}

7.5循环顺序队的入队操作(核心2)

注意：这里需要传入结构指针，因为要修改结构体中成员：修改头指针

bool Dequeue(Queue * q,QElemType * e)
7.5.1算法步骤：

（1）判断队列是否为空
（2）保存队头元素
（3）更新头指针，指向新的队头结点

//4.循环顺序队的出队操作
//注意：这里需要传入结构指针，因为要修改结构体中成员：修改头指针
bool Dequeue(Queue * q,QElemType * e)
{
	//[1]判断队列是否为空
	if (q->rear == q->front)
	{
		return false;//队空
	}

	//[2]保存队头元素
	*e = q->data[q->front];

	//[3]更新头指针，指向新的队头结点
	//这里对MAXQSIZE进行取余,是为了应对以下情况(防止上溢出)
	//头指针指向数组最后一个空间（front+1==MAXQSIZE），要更新头指针指向数组第一个空间时(front == 0) 
	//因为 MAXQSIZE % MAXQSIZE == 0
	q->front = (q->front + 1) % MAXQSIZE;
	return true;
}

7.6循环顺序队的取队头元素操作(核心3)

注意：这里不需要传入结构指针，因为不修改结构体中成员，仅传出元素

bool GetFront(Queue q, QElemType* e)
7.6.1算法步骤：

（1）判断是否队空
（2）取出队头元素

//5.循环顺序队的取队头元素操作
//注意：这里不需要传入结构指针，因为不修改结构体中成员，仅传出元素
bool GetFront(Queue q, QElemType* e)
{
	//[1]判断是否队空
	if (q.rear == q.front)
	{
		return false;//队空
	}

	//[2]取出队头元素
	*e = q.data[q.front];
	
	return true;
}

7.7循环顺序队的清空操作

注意：这里需要传入结构指针，因为要修改结构体中成员；头尾指针

bool ClearQueue(Queue* q)
7.7.1算法步骤

（1）直接将头尾指针重置为0

//6.循环顺序队的清空操作
//注意：这里需要传入结构指针，因为要修改结构体中成员；头尾指针
bool ClearQueue(Queue* q) 
{
	//[1]直接将头尾指针重置为0
	//注意：这里是逻辑上的清空，物理上并没有清空队列，只是重置了头尾指针
	//在入队新元素时，是可以将原来队列中可能存在的元素覆盖掉的
	q->front = q->rear = 0; // 重置头尾指针
	return true;
}

7.8循环顺序队的销毁操作

注意：这里需要传入结构指针，因为要修改结构体中成员；头尾指针，并释放数组空间

bool DestroyQueue(Queue* q)
7.8.1算法步骤

（1）直接销毁存储队列元素的动态数组
（2）注意重置头尾指针

//7.循环顺序队的销毁操作
//注意：这里需要传入结构指针，因为要修改结构体中成员；头尾指针，并释放数组空间
bool DestroyQueue(Queue* q) 
{
	//[1]直接销毁存储队列元素的动态数组
	if (q->data) 
	{
		free(q->data); // 释放动态分配的内存
		q->data = NULL;
	}

	//[1]注意重置头尾指针
	q->front = q->rear = 0; // 重置指针
	return true;
}

7.9遍历队列并打印（从队头开始）

bool TraverseQueue(Queue* q)
7.9.1算法步骤：

（1）初始化计数器等于头指针的值
（2）循环遍历队列元素
注意更新计数器时的取模操作（i+1==MAXQSIZE时,i更新到下标为0处），保证循环结构的正确性

//8.遍历队列并打印（从队头开始）
bool TraverseQueue(Queue* q)
{
	//[1]初始化计数器等于头指针的值
	int i = q->front;

	//[2]循环遍历队列元素
	while (i != q->rear) 
	{
		printf("%d ", q->data[i]);
		i = (i + 1) % MAXQSIZE;
		//注意更新计数器时的取模操作，保证循环结构的正确性
	}
	printf("\n");
	return true;
}

7. 10所有操作汇总：

//循环顺序队列（动态数组，用浪费一个数组空间的方式来解决）
#include<stdio.h>
#include<stdlib.h>


#define MAXQSIZE 100//最大队列长度

#define bool int
#define true 1
#define false 0

typedef int QElemType;


//1.队列的顺序存储结构
typedef struct Queue
{
	QElemType * data;//存储元素的动态数组
	int front;//头指针，若队列不空，指向队列头元素
	int rear;//尾指针，若队列不空，指向队列尾元素的下一个位置
	//注意这里的头尾指针并不是指针变量，而是用下标模拟指针功能的int变量
}Queue;
//Queue：用来定义循环顺序对列



//1.循环顺序队的初始化
//注意：这里需要传入结构指针，因为要修改结构体中成员进行动态分配内存
bool InitQueue(Queue *q)
{
	//[1]为循环顺序对动态分配空间
	q->data=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
	//这里由于数组首地址为一个指针，故可以使用q.data来接受mallocmalloc返回的指针

	if (!q->data)
	{
		return false;//内存分配失败
	}

	//[2]初始化头尾指针为0，表示队列为空
	q->front=q->rear=0;
	return true;
}

//2.求循环顺序队的长度
//注意：这里不用传入结构指针，因为只计算长度，不改变结构体
int QueueLength(Queue q)
{
	//[1]（尾指针 与 头指针作差 再加MAXQSIZE）并取余MAXQSIZE，得到队列长度
	//注意这里加MAXQSIZE并取余MAXQSIZE，是防止尾指针在低地址端
	return (q.rear - q.front + MAXQSIZE) % MAXQSIZE;
}



//3.循环顺序队的入队操作
//注意：这里需要传入结构指针，因为要修改结构体中成员：传入元素，修改尾指针
bool EnQueue(Queue * q,QElemType e)
{
	
	//[1]判断队列是否已满
	//这里对MAXQSIZE进行取余,是为了应对以下情况
	//尾指针指向数组最后一个空间（rear+1==MAXQSIZE），头指针指向数组第一个空间时(rear==0)
	//因为 MAXQSIZE % MAXQSIZE == 0
	if ((q->rear + 1) % MAXQSIZE == q->front)
	{
		return false;//队满
	}

	//[2]进行入队操作
	//<1>新元素插入到当前尾指针指向的空间（当前队尾元素的下一个位置）
	q->data[q->rear] = e;
	//<2>更新尾指针，指向新的队尾结点的下一个位置
	//这里对MAXQSIZE进行取余,是为了应对以下情况(防止上溢出)
	//尾指针指向数组最后一个空间（rear+1==MAXQSIZE），要更新尾指针指向数组第一个空间时(rear==0)   
	//因为 MAXQSIZE % MAXQSIZE == 0
	q->rear = (q->rear + 1) % MAXQSIZE;

	return true;
}

//4.循环顺序队的出队操作
//注意：这里需要传入结构指针，因为要修改结构体中成员：修改头指针
bool Dequeue(Queue * q,QElemType * e)
{
	//[1]判断队列是否为空
	if (q->rear == q->front)
	{
		return false;//队空
	}

	//[2]保存队头元素
	*e = q->data[q->front];

	//[3]更新头指针，指向新的队头结点
	//这里对MAXQSIZE进行取余,是为了应对以下情况(防止上溢出)
	//头指针指向数组最后一个空间（front+1==MAXQSIZE），要更新头指针指向数组第一个空间时(front == 0) 
	//因为 MAXQSIZE % MAXQSIZE == 0
	q->front = (q->front + 1) % MAXQSIZE;
	return true;
}



//5.循环顺序队的取队头元素操作
//注意：这里不需要传入结构指针，因为不修改结构体中成员，仅传出元素
bool GetFront(Queue q, QElemType* e)
{
	//[1]判断是否队空
	if (q.rear == q.front)
	{
		return false;//队空
	}

	//[2]取出队头元素
	*e = q.data[q.front];
	
	return true;
}

//6.循环顺序队的清空操作
//注意：这里需要传入结构指针，因为要修改结构体中成员；头尾指针
bool ClearQueue(Queue* q) 
{
	//[1]直接将头尾指针重置为0
	//注意：这里是逻辑上的清空，物理上并没有清空队列，只是重置了头尾指针
	//在入队新元素时，是可以将原来队列中可能存在的元素覆盖掉的
	q->front = q->rear = 0; // 重置头尾指针
	return true;
}



//7.循环顺序队的销毁操作
//注意：这里需要传入结构指针，因为要修改结构体中成员；头尾指针，并释放数组空间
bool DestroyQueue(Queue* q) 
{
	//[1]直接销毁存储队列元素的动态数组
	if (q->data) 
	{
		free(q->data); // 释放动态分配的内存
		q->data = NULL;
	}

	//[1]注意重置头尾指针
	q->front = q->rear = 0; // 重置指针
	return true;
}


//8.遍历队列并打印（从队头开始）
bool TraverseQueue(Queue* q)
{
	//[1]初始化计数器等于头指针的值
	int i = q->front;

	//[2]循环遍历队列元素
	while (i != q->rear) 
	{
		printf("%d ", q->data[i]);
		i = (i + 1) % MAXQSIZE;
		//注意更新计数器时的取模操作，保证循环结构的正确性
	}
	printf("\n");
	return true;
}

// 主函数测试代码
int main() 
{
	Queue q;

	// 初始化队列
	if (InitQueue(&q)) {
		printf("初始化队列成功！\n");
	}

	// 入队操作
	for (int i = 1; i <= 10; i++) 
	{
		EnQueue(&q, i);
	}

	// 遍历队列
	printf("队列中的元素: ");
	TraverseQueue(&q);

	// 出队操作
	int e;
	Dequeue(&q, &e);
	printf("出队元素: %d\n", e);

	// 再次遍历队列
	printf("队列中的元素: ");
	TraverseQueue(&q);

	// 取队头元素
	GetFront(q, &e);
	printf("队头元素: %d\n", e);

	// 清空队列
	ClearQueue(&q);
	printf("队列清空后长度: %d\n", QueueLength(q));

	// 销毁队列
	DestroyQueue(&q);

	return 0;
}

在这里插入图片描述

float_com
关注
  • 23
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之python实现循环顺序队列
不服输的南瓜的博客
02-25 2584
定义： 对于普通顺序队列，可能队列提示已满，但其实队头还有空位置，这时候就可以考虑用循环顺序队列,把新元素放在队头的空闲位置。 python实现： ...
c语言实现顺序循环队列
qq_42204238的博客
04-22 2889
队列简称队，是一种操作受限的线性表，限制在于仅允许在表的一段进行插入操作，而在表的另一端进行删除操作。 进行插入的一段叫做队尾，进行删除的一端叫做队首，队又称作先入先出表。 队列到顺序表的映射如图： 采用顺序储存结构的队列成为顺序队。 ...
顺序队列的实现（循环队列）
crown的博客
12-01 2546
简单队列 在顺序队列中，通常让队尾指针rear指向刚进队的元素的位置，让队首指针front指向刚出队的元素的位置。因此，元素进队的时候rear指针要向后移动，元素出队的时候front指针也要向后移动。 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #define MAXSIZE 20 typedef int ElemType;...
Java多个线程顺序循环执行的几种实现方式
小马快跑的博客
07-21 6722
文章目录ReentrantLock+Condition方式实现Synchronized+wait/notifyAll方式实现两者对比 ReentrantLock+Condition方式实现 public class ReentrantLock_Impl { private static final String FLAG_THREAD_1 = "ReentrantLock_Thread1"; private static final String FLAG_THREAD_2 = "Reen
顺序队和循环队列，队列篇（顺序队和循环队列入队出队操作）
qq_46104786的博客
11-03 10000
数据结构专升本学习，队列篇（顺序队和循环队列） 前言： 之前我们把栈学完了，比较简单，今天我们学习队列里面的顺序队和循环队列，说难不难，说简单不简单，我们需要认真学习，博主会尽力把原理和逻辑讲明白，不懂的童鞋可以认真多看几遍，博主真的很想教会大家。希望大家认真看，有问题的地方可以评论提出来，希望大家，喜欢。 每日一遍，防止早恋： 1.什么是队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进
C语言实现循环队列
热门推荐
qq_43629857的博客
06-24 1万+
详解循环队列的巧妙之处
python实现循环_python怎么实现循环
weixin_33128703的博客
12-28 3132
python中循环主要有for循环和while循环。while循环如果条件成立(true)，重复执行相同操作，条件不符合，跳出循环while 循环条件:循环操作while循环示例：输入王晓明5门课程的考试成绩，计算平均成绩1 i=1 # 初始化循环计数器i2 sum=0 ...
顺序循环队列的基本操作（C语言实现）
m0_61395860的博客
02-09 8866
一、队列和循环队列基本概念 队列: 和栈相反，队列是一种先进先出（FIFO）的线性表。只允许在一端插入，在另一端删除。 允许插入的叫"队尾"（rear），允许删除的叫"队头"（front）。 入队操作：L->rear++; L->data[L->rear]=x;（需要入队的元素） 出队操作：L->front++; x=L->data[L->front]; 求队长：队长=(L->rear)-(L->front);...
《数据结构初阶》实现顺序循环队列和链式队列
m0_62171658的博客
03-28 4106
数组实现循环队列、单链表实现队列接口实现全解
数据结构学习笔记——顺序存储结构实现循环队列
小宇y的博客
06-12 4322
所谓循环队列，也就是将顺序队列中的一维数组首尾相连成环，也就是在逻辑上视为一个环连接起来，其存储类型定义与顺序队列的存储类型定义是一样的，也是定义数组data[MaxSize]和两个指针，即队头指针front指向队头元素，队尾指针rear指向队尾元素，如下： 例如下图是个空循环队列，其中data[]数组中未存任何数据元素，指针front、rear都指向同一位置，此时队列为空： 循环队列的初始化与顺序队列的初始化代码一样，当时，表示循环队列的初始状态，此时队列为空，如下代码： 三、判断循环队列是否为空队 循环
循环队列详解及队列的顺序表示和实现
08-31
同时，还提供了一系列的函数接口来实现循环队列的基本操作，如初始化（`queue_init`）、判断队列是否为空（`queue_empty`）、插入元素（`queue_en`）、出队（`queue_de`）、清空队列（`queue_clear`）、获取队头元素...
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队
06-04
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队 适合大二初学数据结构与算法 程序有详细备注，可直接运行 顺序表
java队列实现方法(顺序队列,链式队列,循环队列)
08-28
Java 中提供了多种实现队列的方法，包括顺序队列、链式队列和循环队列等。下面我们将详细介绍每种队列的实现方法和特点。 一、顺序队列 顺序队列是指使用数组来实现队列的数据结构。它的特点是元素在数组中的位置...
C++数据结构之实现循环顺序队列
08-31
循环顺序队列中的每个元素都有其前驱和后继元素，除非它是队头或队尾元素。为了提高操作效率，通常会设置两个指针，一个指向队头元素的前一个位置（front），另一个指向队尾元素（rear）。 队列的两个关键操作是...
Python-MNE-源定位和逆问题01：源估计（SourceEstimate）数据结构
weixin_58312922的博客
08-25 668
stc是MNE-Python的一个类，表示从源估计中获得的转换的时间序列。对于两个半球，数据分别存储在和中，储存形式为的形式为一个m*n的矩阵，m是这个半球的空间位置的数量，n是时间点的个数。和对应和。这些是表面表征的位置索引。表面的坐标存储在和中，分别表示左半球和右半球。
集合及数据结构第十节（下）————常用接口介绍、堆的应用和java对象的比较
2301_79418684的博客
08-25 806
常用接口介绍和堆的应用 1. PriorityQueue的特性 2. .PriorityQueue常用接口介绍 3. top-k问题 4. 堆排序 5. PriorityQueue中插入对象 6. 元素的比较 7. .对象的比较 8. .集合框架中PriorityQueue的比较方式
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 556
数组，双链表实现队列，附完整代码
数据结构之链表
WSH2012ffff的博客
08-27 623
本文从链表的定义、创建、遍历、插入、删除等多个方面进行了详细讲解，希望能够帮助大家更好地理解和掌握c/c++语言中的链表操作。链表是一种动态数据结构，由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表是计算机科学中常见的一种数据结构，c/c++语言中也有着丰富的链表操作函数库。在c/c++中，可以使用结构体来定义一个节点，并用指针来表示节点之间的关系，从而实现链表。链表遍历是指按照一定的顺序依次访问链表中的每一个节点。链表删除是指在链表中删除一个节点。
Linux 数据结构 链表
最新发布
mxyzhy的博客
08-28 227
单向链表操作
如何实现循环队列顺序存储
05-13
循环队列顺序存储是一种基于数组的队列实现方式，与普通队列相比，它可以更好地利用数组空间，并且可以循环使用数组中的空间。 具体实现步骤如下： 1. 定义一个数组，同时定义队头和队尾指针 front 和 rear，初始值都为 0。 2. 入队时，先判断队列是否已满（即 (rear+1) % 数组长度 == front），如果已满则入队失败，否则将元素添加到队尾，并将 rear 指针加 1。 3. 出队时，先判断队列是否为空（即 front == rear），如果为空则出队失败，否则将队头元素弹出，并将 front 指针加 1。 4. 队列中的元素个数为 (rear - front + 数组长度) % 数组长度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值