数据结构—队列(Ⅴ)

已于 2022-03-19 09:31:05 修改
阅读量750 收藏 2
点赞数 1
分类专栏： 计算机技术 文章标签： 数据结构 队列 算法 c语言 visual studio
于 2021-08-06 06:51:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42071236/article/details/119357169
版权

目录

数据结构-队列(第三章)的整理笔记，若有错误，欢迎指正。
栈

队 列 的 基 本 操 作 ( “ & ” 表 示 引 用 调 用 ) { I n i t Q u e u e ( & q ) ： 初 始 化 队 列 ， 构 造 一 个 空 队 列 q 。 Q u e u e E m p t y ( q ) ： 判 断 队 列 是 否 为 空 ， 若 队 列 q 为 空 ， 则 返 回 真 ； 否 则 返 回 假 。 e n Q u e u e ( & q , e ) ： 进 队 列 ， 将 元 素 e 进 队 作 为 队 尾 元 素 。 d e Q u e u e ( & q , & e ) ： 出 队 列 ， 从 队 列 中 出 队 一 个 元 素 ， 并 将 其 值 赋 给 e 。 D e s t r o y Q u e u e ( & q ) ： 销 毁 队 列 ， 释 放 队 列 q 占 用 的 存 储 空 间 。 队列的基本操作(“\&”表示引用调用)\begin{cases} InitQueue(\&q)：初始化队列，构造一个空队列q。\\ QueueEmpty(q)：判断队列是否为空，若队列q为空，则返回真；否则返回假。\\ enQueue(\&q,e)：进队列，将元素e进队作为队尾元素。\\ deQueue(\&q,\&e)：出队列，从队列中出队一个元素，并将其值赋给e。\\ DestroyQueue(\&q)：销毁队列，释放队列q占用的存储空间。\\ \end{cases} 队列的基本操作(“&”表示引用调用)⎩⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎧​InitQueue(&q)：初始化队列，构造一个空队列q。QueueEmpty(q)：判断队列是否为空，若队列q为空，则返回真；否则返回假。enQueue(&q,e)：进队列，将元素e进队作为队尾元素。deQueue(&q,&e)：出队列，从队列中出队一个元素，并将其值赋给e。DestroyQueue(&q)：销毁队列，释放队列q占用的存储空间。​


队列的顺序存储结构

队列的顺序存储类型描述

typedef struct
{
	ElemType data[MaxSize]; //存放队中元素
	int front, rear; //对头和队尾指针
}SqQueue; //顺序队类型

初始化队列—InitQueue(&q)

void InitQueue(SqQueue &q)
{
	q.front = q.rear = 0; //初始化队首、队尾指针
}

判断队列是否为空—QueueEmpty(q)

bool QueueEmpty(SqQueue q)
{
	return q.rear == q.front;
}

进队列—enQueue(&q,e)

bool enQueue(SqQueue& q, ElemType e)
{
	if (q.rear == MaxSize - 1) return false;
	q.data[q.rear++] = e; 
	return true;
}

分析

  • 顺序队操作中，元素进队时队尾指针rear增1，元素出队时队头指针front增1，当队满的条件(即rear== Max Size-1)成立时，表示此时队满(上溢出)了，不能再进队元素。实际上，当rear== Maxsize-1成立时，队列中可能还有空位置，这种因为队满条件设置不合理导致队满条件成立而队列中仍然有空位置的情况称为假溢出。

出队列—deQueue(&q,&e)

bool deQueue(SqQueue& q, ElemType &e)
{
	if (q.rear == q.front) return false;
	e = q.data[q.front++];
	return true;
}

销毁队列—DestroyQueue(&q)

void Destroy(SqQueue*& q)
{
	free(q.data);
}

完整代码(静态队列)

#include<iostream>
using namespace std;
#define MaxSize 10
typedef int ElemType;
typedef struct
{
	ElemType data[MaxSize];
	int front, rear;
}SqQueue;

void InitQueue(SqQueue& q)
{
	q.front = q.rear = 0; //初始化队首、队尾指针
}

bool QueueEmpty(SqQueue q)
{
	return q.rear == q.front;
}

bool enQueue(SqQueue& q, ElemType e)
{
	if (q.rear == MaxSize) return false;
	q.data[q.rear++] = e;
	return true;
}

bool deQueue(SqQueue& q, ElemType& e)
{
	if (q.rear == q.front) return false;
	e = q.data[q.front++];
	return true;
}

void PriQueue(SqQueue& q)
{
	int i, j = q.rear, num;
	for (i = 0; i < j; i++)
	{
		deQueue(q, num);
		printf("%d ", num);
	}
}

int main()
{
	SqQueue q;
	InitQueue(q);
	cout << "队列为空吗？—" << boolalpha << QueueEmpty(q) << endl;
	ElemType num;
	printf("输入：");
	scanf("%d", &num);
	while (num != 999)
	{
		enQueue(q, num);
		scanf("%d", &num);
	}
	cout << "队列为空吗？—" << boolalpha << QueueEmpty(q) << endl;
	PriQueue(q);
	return 0;
}

分析

  • 静态队列数组长度固定，不可更改，最多只能存MaxSize个数。
    在这里插入图片描述

部分代码(动态队列)

#include<iostream>
#include<malloc.h>
using namespace std;
#define InitSize 10
typedef int ElemType;
typedef struct
{
	int *data;
	int MaxSize;
	int front, rear;
}SqQueue;

void InitQueue(SqQueue& q)
{
	q.data = (int*)malloc(sizeof(int) * InitSize);
	q.front = q.rear = 0; //初始化队首、队尾指针
	q.MaxSize = InitSize;
}

bool QueueEmpty(SqQueue q)
{
	return q.rear == q.front;
}

bool IncreaseSize(SqQueue& q, int len)
{
	int* p = q.data; //定义整型指针变量，指向队列的首地址
	q.data = (int*)malloc(sizeof(int) * (q.MaxSize + len)); //申请一片更大的连续的存储空间
	if (q.data == NULL) return false; //没有连续的存储空间，分配失败
	for (int i = 0; i < q.MaxSize; i++)
		q.data[i] = p[i]; //将数据复制到新的存储区域中
	q.rear = q.MaxSize;
	q.MaxSize = q.MaxSize + len; //队列的最大长度增加
	free(p); //释放原来的内存空间
	return true;
}

bool enQueue(SqQueue& q, ElemType e)
{
	ElemType num;
	if (q.rear == InitSize) IncreaseSize(q, q.MaxSize);
	q.data[q.rear++] = e;
	return true;
}

bool deQueue(SqQueue& q, ElemType& e)
{
	if (q.rear == q.front) return false;
	e = q.data[q.front++];
	return true;
}

void PriQueue(SqQueue& q)
{
	int i, j = q.rear, num;
	for (i = 0; i < j; i++)
	{
		deQueue(q, num);
		printf("%d ", num);
	}
}

void DestroyQueue(SqQueue& q)
{
	free(q.data);
}

int main()
{
	SqQueue q;
	InitQueue(q);
	cout << "队列为空吗？—" << boolalpha << QueueEmpty(q) << endl;
	ElemType num;
	printf("输入：");
	scanf("%d", &num);
	while (num != 999)
	{
		enQueue(q, num);
		scanf("%d", &num);
	}
	cout << "队列为空吗？—" << boolalpha << QueueEmpty(q) << endl;
	PriQueue(q);
	return 0;
}

分析

  • 上述5个基本运算算法的时间复杂度均为O(1);
    在这里插入图片描述

环形队列

  • 可以看出，在出现假溢出时队尾指针rear指向data数组的最大下标，而另外一端还有若干个空位置。
  • 解决的方法是把data数组的前端和后端连接起来，形成一个环形数组，即把存储队列元素的数组从逻辑上看成一个环，称为环形队列或者循环队列(circular queue)。
  • 环形队列首尾相连后，当队尾指针rear= Maxsize-1后，再前进一个位置就到达0，于是就可以使用另一端的空位置存放队列元素了。实际上存储器中的地址总是连续编号的，为此采用数学上的求余运算(%)来实现：
//队头指针front循环增1: 
front = (front + 1) % MaxSize
//队尾指针rear循环增1：
rear = (rear + 1) % MaxSize
//队列长度：
(q->rear + MaxSize - q->front) % MaxSize
  • 环形队列的队头指针front和队尾指针rear初始化时都置为0，即 front=rear=0。在进队元素和出队元素时，队尾指针和队头指针分别循环增1。
    在这里插入图片描述

三种处理方式区分是队空还是队满的情况

  1. 牺牲一个单元来区分队空和队满，入队时少用一个队列单元(普遍的做法)，约定以“队头指针在队尾指针的下一位置作为队满的标志”。
  • 设置队空条件是：q->rear==q->ront；队满条件是(q->rear+1)%Maxsize==q->front。而进队操作和出队操作改为分别将队尾指针rear和队头指针front循环进1。

进队列—enQueue(&q,e)

bool enQueue(SqQueue*& q, ElemType e)
{
	if ((q->rear + 1) % MaxSize == q->front) return false; //队空则报错
	q->data[q->rear] = e; 
	q->rear = (q->rear + 1) % MaxSize; //队尾指针加1取模
	return true;
}

出队列—deQueue(&q,&e)

bool deQueue(SqQueue*& q, ElemType &e)
{
	if (q->rear == q->front) return false; //队满则报错
	e = q->data[q->front];
	q->front = (q->front + 1) % MaxSize; //队头指针加1取模
	return true;
}
  1. 类型中增设表示元素个数的数据成员，入队时q.size++，出队时q.size--。
  • 设置队空的条件为q.size==0；队满的条件为q.size==MaxSize。

类型中增设表示元素个数的数据成员：

typedef struct
{
	ElemType data[MaxSize]; //存放队中元素
	int front, rear; //对头和队尾指针
	int size; //队列当前长度
}SqQueue; //顺序队类型

初始化时将size设置为0：

void InitQueue(SqQueue *&q)
{
	q = (SqQueue*)malloc(sizeof(SqQueue));
	q->front = q->rear = 0; //初始化队首、队尾指针
	q->size = 0;
}

进队列—enQueue(&q,e)

bool enQueue(SqQueue*& q, ElemType e)
{
	if (q->size==MaxSize) return false;
	q->data[q->rear++] = e; 
	q->size++;
	printf("size:%d ", q->size);
	return true;
}

出队列—deQueue(&q,&e)

bool deQueue(SqQueue*& q, ElemType &e)
{
	if (q->size==0) return false;
	e = q->data[q->front++];
	q->size--;
	return true;
}
  1. 类型中增设tag数据成员，以区分是队满还是队空。只有删除操作，才可能导致队空；只有插入操作，才可能导致队满。
  • tag等于0时，若因删除导致q.front==q.rear，则为队空；tag等于1时，若因插入导致q.front==q.rear，则为队满。

类型中增设表示元素个数的数据成员：

typedef struct
{
	ElemType data[MaxSize]; //存放队中元素
	int front, rear; //对头和队尾指针
	int tag; //最近进行的是删除/插入
}SqQueue; //顺序队类型

初始化时将size设置为0：

void InitQueue(SqQueue *&q)
{
	q = (SqQueue*)malloc(sizeof(SqQueue));
	q->front = q->rear = 0; //初始化队首、队尾指针
	q->tag = 0;
}

进队列—enQueue(&q,e)

bool enQueue(SqQueue*& q, ElemType e)
{
	if (q->front == q->rear && q->tag == 1) return false;
	q->data[q->rear++] = e; 
	q->tag = 1;
	return true;
}

出队列—deQueue(&q,&e)

bool deQueue(SqQueue*& q, ElemType &e)
{
	if (q->rear == q->front && q->tag == 0) return false;
	e = q->data[q->front++];
	q->tag == 0;
	return true;
}

队列的链式存储结构

队列的链式存储类型描述

typedef struct LinkNode//链式队列结点
{
	ElemType data;
	struct LinkNode* next;
}LNode;
typedef struct //链式队列
{
	LNode* front, * rear; //队列的队头和队尾
}LinkQueue;

在这里插入图片描述

初始化队列—InitQueue(&q)

void InitQueue(LinkQueue*& q)
{
	q = (LinkQueue*)malloc(sizeof(LinkQueue)); //建立头结点
	q->front = q->rear = NULL; //初始为空
}

判断队列是否为空—QueueEmpty(q)

bool EmptyQueue(LinkQueue*& q)
{
	return q->rear == NULL;
}

进队列—enQueue(&q,e)

void enQueue(LinkQueue*& q, ElemType e)
{
	LinkNode* s;
	s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = e;
	s->next = NULL;
	if (q->rear == NULL) q->front = q->rear = s; //创建新节点，插入到链尾
	else
	{
		q->rear->next = s;
		q->rear = s;
	}
}

出队列—deQueue(&q,&e)

bool deQueue(LinkQueue*& q, ElemType& e)
{
	LinkNode* p;
	if (q->rear == NULL) return false; //空队
	p = q->front;
	q->front->next = p->next;
	if (q->rear == q->front) q->rear = q->front = NULL; //若队列中只有一个结点，删除后变空
	else q->front = q->front->next;
	e = p->data;
	free(p);
	return true;
}

销毁队列—DestoryQueue(&q)

void DestoryQueue(LinkQueue*& q)
{
	LinkNode* p = q->front, * r;
	if (p != NULL)
	{
		r = p->next;
		while (r != NULL)
		{
			free(p);
			p = r;
			r = p->next;
		}
	}
	free(p);
	free(q);
}

完整代码(带头结点的链式队列)

#include<iostream>
using namespace std;
#include<malloc.h>
typedef int ElemType;
typedef struct LinkNode//链式队列结点
{
	ElemType data;
	struct LinkNode* next;
}LNode;
typedef struct //链式队列
{
	LNode* front, * rear; //队列的队头和队尾
}LinkQueue;

void InitQueue(LinkQueue*& q) //初始化队列
{
	q = (LinkQueue*)malloc(sizeof(LinkQueue)); //建立头结点
	q->front = q->rear = NULL;
}

bool IsEmpty(LinkQueue *q) //判断队列是否为空
{
	return q->rear == q->front;
}

void EnQueue(LinkQueue*& q,BTree t)
{
	LNode* p = (LNode*)malloc(sizeof(LNode)); //创建新结点
	p->data = t; //插入到队尾
	p->next = NULL;
	q->rear->next = p;
	q->rear = p;
}

bool DeQueue(LinkQueue*& q, BTree &t)
{
	LNode* p = q->front->next;
	if (q->rear == q->front) return false; //空队
	t= p->data;
	p = p->next;
	if (q->rear == p) q->rear = q->front; //若原队列中只有一个结点，删除后变空
	free(p);
	return true;
}

void DestoryQueue(LinkQueue*& q)
{
	LinkNode* p = q->front, * r;
	if (p != NULL)
	{
		r = p->next;
		while (r != NULL)
		{
			free(p);
			p = r;
			r = p->next;
		}
	}
	free(p);
	free(q);
}

int main()
{
	LinkQueue *q;
	
	InitQueue(q);
	cout << boolalpha << "队列为空吗？—" << EmptyQueue(q) << endl;
	int i;
	for (i = 0; i < 10; i++)
		enQueue(q, i);
	cout << boolalpha << "队列为空吗？—" << EmptyQueue(q) << endl;
	ElemType num;
	for (i = 0; i < 10; i++)
	{
		deQueue(q, num);
		cout << num << ' ';
	}
	DestoryQueue(q);
	return 0;
}

部分代码(不带头结点的链式队列)

void InitQueue(LinkQueue*& q)
{
    q->rear = q->front = NULL; //初始化队列
}

bool EmptyQueue(LinkQueue *q)
{
    return (q->front == NULL); //判空条件:头指针是否为空
}
void enQueue(LinkQueue*& q, ElemType e)
{
    LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
    s->data = e;
    s->next = NULL;
    if (EmptyQueue(q)) //如果队列为空，则将头指针尾指针同时指向新插入的节点
    {
        q->front = s;
        q->rear = s;
        return;
    }
    q->rear->next = s;
    q->rear = s;
}

bool deQueue(LinkQueue*& q, ElemType& e)
{
    if (q->front == NULL)
        return false;
    LinkNode* p = q->front; //p指向头指针
    e = p->data;
    q->front = p->next; //队列的头指针指向p指针的下一节点
    if (q->rear == p) q->rear = q->front = NULL; //此次是最后一个节点，队列置空
    free(p);
    return true;
}

void DestoryQueue(LinkQueue*& q)
{
    LinkNode* p = q->front, * r;
    if (p != NULL)
    {
        r = p->next;
        while (r != NULL)
        {
            free(p);
            p = r;
            r = p->next;
        }
    }
    free(p);
}

分析

  • 入队时不考虑队满的条件。

双端队列

  • 双端队列是一种具有队列和栈的性质的数据结构，是指两端都可以进行进队和出队操作的队列。
—Miss. Z—
关注
专栏目录
【Java数据结构】一文搞懂优先级队列（堆）
耀的博客
12-10 2830
一文搞懂优先级队列（堆）
六万字数据结构基础知识大总结(含笔试面试习题)
耀的博客
12-24 3359
Java数据结构大总结，适合新手入门学习，总结，创作不易，求点赞，求收藏，让我们一起学起来！！！
数据结构（6）
weixin_43558339的博客
07-31 173
链队 创建链队中头节点类型 typedef struct {QNode *front; QNode *rear; }LiQueue; 1、初始化队列InitQueue(q) void InitQueue(LiQueue *&q) { q=(LiQueue *)malloc(sizeof(LiQueue)); q->front=q->rear=null; } 2、销毁队列De...
SV数据类型-队列
weixin_42263208的博客
06-29 1万+
1.队列结合了链表和数组的优点，可以在它的任何地方添加或删除元素，并且通过索引实现对任一元素的访问。 2.队列的声明是使用带有美元符号的下标：[$]，队列元素的标号从0到$。 3.队列不需要new[ ]去创建空间，只需要使用队列的方法为其增减元素，一开始其空间为0。 4队列的一个简单使用：通过其自带方法push_back( )和pop_front( )的结合来实现FIFO的用法。（从back往里放，从front往外拿） eg:int j = 1， q2[$] = {3,4},q[$] =..
队列的顺序存储（循环队列）和链式存储（带和不带头结点）C/C++实现
qq_49818809的博客
04-01 2105
队列的顺序存储（循环队列）和链式存储（带和不带头结点）C/C++实现 文章目录队列的顺序存储（循环队列）和链式存储（带和不带头结点）C/C++实现@[TOC](文章目录)一、循环队列1.引入库二、链式队列（带头结点）1.引入库2.读入数据三、链式队列（ 不带头结点）四、总结 由于队列的顺序存储中存在“假溢出”或“上溢出”，一般在使用中会采用循环队列或链式队列，下面给出循环队列和链式队列（带和不带头结点）的实现。 一、循环队列
循环队列的顺序表示和实现
qq_57867712的博客
11-11 447
一、顺序队列的存储结构 #define MAXSIZE 100//队列可能达到的最大长度 typedef int QElemType; //队列的顺序存储结构 typedef struct { QElemType *base;//存储空间的基地址 int front;//头指针 int rear;//尾指针 } SqQueue; 二、循环队列的初始化 算法步骤： （1）为队列分配一个最大容量为MAXSIZE的数组空间，base指向数组空间的首地址。 （2）头指针和尾指针置
顺序队列和链式队列
coding change your life
08-30 482
顺序队列 链式队列 #include #include typedef int ElemType; typedef struct LinkNode{ ElemType data; LinkNode *next; }LinkNode; typedef struct { LinkNode *front,*rear; }LinkQueue; void initQueue(Lin
数据结构 树、图、查找、排序习题整合
lseaJK的博客
06-29 3286
数据结构第六章 树和森林第七章 图第八章 查找第九章 排序 第六章 树和森林 二叉树的第k层节点数最多为（2k-1）。 将森林F 转换为对应的二叉树T，F中叶结点的个数等于（） 【答】二叉树变森林方法为右孩子A变兄弟节点。若该孩子节点A有左孩子，则带着左孩子一起分离形成独立的树。若无左孩子，则成为孤立节点。 若用链表存储一棵二叉树时，每个结点除数据域外，还有指向左孩子和右孩子的两个指针。在这种存储结构中，n个结点的二叉树共有（2n）个指针域，其中有（n-1）个指针域是存放了地址，有（n+1）个指针是空指针
【数据结构与算法】-＞算法-＞深度优先搜索&广度优先搜索
欢迎来到新世界
09-12 1113
深度&广度 优先搜索Ⅰ 前言Ⅱ 什么是“搜索”算法？Ⅲ 广度优先搜索（BFS）Ⅳ 深度优先搜索（DFS） Ⅰ 前言 在前一篇文章中，我讲解了图的概念以及图的表示方法，也讲了如何用无向图、有向图来表示一个社交网络。要是对图还不熟悉的同学可以先跳转去看看。 【数据结构与算法】-＞数据结构-＞图 这篇文章就来讲讲两个搜索算法，深度优先搜索和广度优先搜索。 Ⅱ 什么是“搜索”算法？ 我们知道，算法是作用于具体数据结构之上的，深度优先搜索算法和广度优先搜索算法都是基于“图”这种数据结构的，因为图的表达能力很强
队列管理1
最新发布
pirate5211的博客
11-29 207
队列管理
算法导论-图算法Part1
张丰的博客
01-19 280
1. 图的表示：1. 邻接链表：稀疏图;2. 邻接矩阵：稠密图;2. 广度优先搜索（1） 算法思想：1. 初始化结点、队列；同时根结点入队;2. 出队操作，同时将所有该结点的未被访问到的相邻结点入队；3. 队列为空则算法结束。（2）伪代码：第一部分：初始化每个结点，队列；第二部分：while Q!=null    u=DeQueue(Q);    for  v in G.Adj[u]       
数据结构（顺序队列/链队列//循环队列）
Kerryliuyue的博客
11-10 159
顺序队列 #include<iostream> #include<malloc.h> using namespace std; typedef int ElemType; const int MaxSize=200; typedef struct { ElemType data[MaxSize]; int rear,front; }SqQueue; void InitQueue(SqQueue *&s) { s=(SqQueue *)malloc(
数据结构之——队列的操作
delete_bug的博客
05-16 483
顺序队列 #include <iostream> using namespace std; //顺序队列 #define MaxSize 10 typedef struct { int data[MaxSize]; int front, rear; }SqQueue; //初始化队列 void Init_Queue(SqQueue *&q) { q = (SqQueue*)malloc(sizeof(SqQueue)); q->front = q->rear = -1
队列相关习题及详解(选择题和综合题) ——数据结构
热门推荐
Amour
10-31 3万+
队列的基本概念队列的定义队列（Queue）：队列简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。这和我们日常生活中的排队是一致的，最早排队的也是最早离队的。其操作的特性是先进先出（First In First Out, FIFO），故又称为先进先出的线性表。队头（Front）：允许删除的一端，又称为首队 队
线性表的基本创建和输入输出
qq_56805519的博客
09-02 6163
#include<iostream> #include<malloc.h> using namespace std; typedef struct SqList{ int *elem; int length; int listsize; }; void InistSqList(SqList &L) //线性表的创建（初始化） { L.elem=(int *)malloc(20*sizeof(int)); //动态分配内存空间 L.length=0; .
树的孩子兄弟表示法完整代码实现
Miss Z的博客
09-01 7062
#include<stdio.h> #include<malloc.h> typedef char ElemType; #define MaxSize 15 typedef struct CSNode { ElemType data; struct CSNode* firstchild, * nextsibling; }CSNode, * CSTree; typedef struct { CSNode* data[MaxSize]; //存放栈中的数据元素 int top;
C语言实现两个多项式相加&相减&相乘运算
Miss Z的博客
11-15 7058
1
树的双亲表示法&孩子表示法代码实现
Miss Z的博客
09-06 6418
孩子表示法 孩子链存储结构的类型声明 typedef struct { int child; //孩子结点在数组中的位置 struct CTNode *next; //下一个孩子 }CTNode; typedef struct { ElemType data; struct CTNode *firstChild; //第一个孩子 }CTBox; typedef struct { CTBox nodes[MAX_TREE_SIZE]; int n,r; //结点数和根的位置 }CTree;
数据结构—共享栈
Miss Z的博客
08-11 6064
数据结构-栈(Ⅳ) 共享栈 利用栈底位置相对不变的特性，可让两个顺序栈共享一个一维数组空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延伸。 共享栈是为了更有效地利用存储空间，两个栈的空间相互调节，只有在整个存储空间被占满时才发生上溢。其存取数据的时间复杂度均为O(1)，所以对存取效率没有什么影响。 栈空条件：栈0空为top0==-1；栈1空为top==MaxSize。 栈满条件：top0==top1-1。 元素x进栈操作：进栈=操作为top0++；data[top0]=x；
Java实现循环队列数据结构
在Java编程中，循环队列是一种特殊的数据结构，它结合了线性表（如数组或链表）和队列的特性。循环队列克服了传统顺序队列在满时容易出现“假溢出”的问题。在循环队列中，队列的首尾相连形成一个环状，使得队列的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值