【EduCoder】实现一个顺序存储的队列

最新推荐文章于 2024-07-25 17:45:03 发布
最新推荐文章于 2024-07-25 17:45:03 发布
阅读量4.2k 收藏 26
点赞数 7
分类专栏： EduCcoder题及题解 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55205575/article/details/121325370
版权

实现一个顺序存储的队列

第1关：实现一个顺序存储的栈

任务描述
本关任务是实现 step1/SeqStack.cpp 中的SS_IsFull、SS_IsEmpty、SS_Length、SS_Push和SS_Pop五个操作函数，以实现判断栈是否为满、是否为空、求栈元素个数、进栈和出栈等功能。

相关知识
栈的基本概念
栈是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算，这一端被称为栈顶。栈既可以采用顺序存储，也可以采用链接存储来实现。下面给出了一种基于顺序存储的栈的实现方案：

在这里插入图片描述
如图 1 所示：该栈存储了 4 个元素 {56,77,15,12} ，其中 12 是栈顶元素。

这种实现方案将栈元素存储在一片连续的空间中，栈相关的三个属性元素data、top和max介绍如下：

  • data: 给出栈存储空间的起始地址；
  • top: 存放栈顶元素的位置编号；
  • max: 指明栈存储空间中最多可存储的数据元素个数。

特别说明：空间的开始地址为data，连续空间里的位置编号从data所指的开始位置起，到该空间的结束位置，编号依次是0,1,2,…,max-1。在图 1 的示例中max=6。栈顶元素的位置编号由top给出。

栈结构的定义（C）

基于data、top、max组织成的栈结构如下所示：

struct SeqStack{
T* data; // 数据元素指针
int top; // 栈顶元素编号
int max; // 最大结点数 };

为了讨论简单，我们假设栈元素的数据类型为整数：

typedef int T; // 栈元素的数据类型

据此，只要给定指向该结构的一指针 ss ，就可对栈进行进栈出栈操作。

  • 进行进栈操作时，新进栈的元素保存在 top+1 位置，进栈后 top 加 1 ，这时的状态则如图 2 所示。
    在这里插入图片描述
  • 进行出栈操作时，将位置编号为 top 的元素出栈，出栈后 top 减去 1 ，这时的状态则如图 3 所示。

在这里插入图片描述
顺序栈的操作
以顺序存储的栈为例，我们定义如下操作：

创建栈：创建一个最多可以存储 maxlen 个元素的顺序栈。具体操作函数定义如下：

SeqStack* SS_Create(int maxlen)；

释放栈空间：释放栈所占用的空间。具体操作函数定义如下：

void SS_Free(SeqStack* ss)；

清空一个栈：将栈中元素清空。具体操作函数定义如下：

void SS_MakeEmpty(SeqStack* ss)；

判断栈是否为满：若栈为满，则返回 true,否则返回false。具体操作函数定义如下：

bool SS_IsFull(SeqStack* ss)；

判断栈是否为空：若栈为空，则返回true，否则返回false。具体操作函数定义如下：

bool SS_IsEmpty(SeqStack* ss)；

求栈元素个数：获取栈元素个数。具体操作函数定义如下：
int SS_Length(SeqStack* ss)；

将元素 x 进栈：将 x 进栈，若满栈则无法进栈，返回false，否则返回true。具体操作函数定义如下：

bool SS_Push(SeqStack* ss, T x)；

出栈：出栈的元素放入 item 。若出栈成功(栈不为空)，则返回true；否则(空栈)，返回false。具体操作函数定义如下：

bool SS_Pop(SeqStack* ss, T &item)；

获取栈顶元素：获取栈顶元素放入 item 中。若获取失败(空栈)，则返回false，否则返回true。具体操作函数定义如下：

bool SS_Top(SeqStack* ss, T & item)；

打印栈中元素：从栈底到栈顶打印出所有元素。具体操作函数定义如下：

void SS_Print(SeqStack* ss)。

编程要求
本关任务是实现 step1/SeqStack.cpp 中的SS_IsFull、SS_IsEmpty、SS_Length、SS_Push和SS_Pop五个操作函数，以实现判断栈是否为满、是否为空、求栈元素个数、进栈和出栈等功能。具体要求如下：

SS_IsFull：判断栈是否为满，若栈为满，则返回 true，否则返回false；

SS_IsEmpty：判断栈是否为空，若栈为空，则返回true，否则返回false；

SS_Length：获取栈元素个数；

SS_Push：将元素 x 进栈，若满栈则无法进栈，返回false，否则返回true；

SS_Pop：若出栈成功(栈不为空)，则返回true；否则(空栈)，返回false；

输入输出格式请参见后续说明及测试样例。

注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的五个操作函数时，在函数体内可调用其他操作。

本关涉及的代码文件 SeqStack.cpp 中的 5 个操作函数的代码框架如下：

bool SS_IsFull(SeqStack* ss)
// 判断栈是否为满。为满返回true，否则返回false。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}


bool SS_IsEmpty(SeqStack* ss)
// 判断栈是否为空。为空返回true，否则返回false。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}


int SS_Length(SeqStack* ss)
// 获取栈元素个数
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}


bool SS_Push(SeqStack* ss, T x)
// 将元素x进栈，若满栈则无法进栈，返回false，否则返回true
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}


bool SS_Pop(SeqStack* ss, T &item)
// 出栈的元素放入item。若出栈成功(栈不为空)，则返回true；否则(空栈)，返回false。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}

测试说明
本关的测试文件是 step1/Main.cpp ，负责对你实现的代码进行测试。具体代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SeqStack.h"
#pragma warning(disable:4996)
void main()
{
    int max;
    scanf("%d", &max);
    SeqStack* ss = SS_Create(max);
    char dowhat[100];
    while(true) {
        scanf("%s", dowhat);
        if (!strcmp(dowhat,"push")) {
            T x;
            scanf("%d", &x);
            SS_Push(ss,x);
        }else if (!strcmp(dowhat,"pop")) {
            T item;
            SS_Pop(ss, item);
        }
        else {
            break;
        }
    }
    int length = SS_Length(ss);
    printf("Stack length: %d\n", length);
    SS_Print(ss);
    SS_Free(ss);
    system("PAUSE");
}

注意：step1/Main.cpp 的代码不能被修改。

输入输出说明：
输入格式：
首先输入一个正整数 max ，创建一个最多可存储 max 个元素的栈。然后输入多个操作：如果输入 “push” ，则后面跟一个数 x ，表示 x 进栈；如果输入 “pop” ，表示出栈操作；如果输入 “end” ，表示输入结束。

输出格式：
输出栈的长度，然后从栈底到栈顶依次输出各元素。

以下是平台对 step1/Main.cpp 的测试样例：
样例输入:

6
push 56
push 15
push 12
push 13
pop
end

样例输出

Stack length: 3
stack data (from bottom to top): 56 15 12

开始你的任务吧，祝你成功！

就算孤独，也不能一个人哭泣，无论走在哪，都要高傲地挺立；就算高压，也不能情愿地趴下，只有仰视生活，膝盖才不至于卑微；就算挫败，也不能窝囊地依靠，无论在何时，都要倔强地站起。前面的路过于平坦，惬意久了难以找到方向；唯有脚下布满了荆棘，前方或许才是生机。

如果你有收获，请在下面点赞。

AC代码：

/*************************************************************
    date: July 2017
    copyright: Zhu En（祝恩）
    DO NOT distribute this code.
**************************************************************/
//顺序存储的栈 实现文件
/
#include <stdio.h>
#include <stdlib.h>
#include "SeqStack.h"

/*创建一个栈*/
SeqStack* SS_Create(int maxlen)
{
	SeqStack* ss=(SeqStack*)malloc(sizeof(SeqStack));
	ss->data=(T*)malloc(maxlen*sizeof(T));
	ss->top=-1;
	ss->max=maxlen;
	return ss;
}

/*释放一个栈*/
void SS_Free(SeqStack* ss)
{
	free(ss->data);
	free(ss);
}

/*清空一个栈*/
void SS_MakeEmpty(SeqStack* ss)
{
	ss->top=-1;
}

/*判断栈是否为满*/
bool SS_IsFull(SeqStack* ss)
{
	/*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
	return ss->top+1==ss->max;
    /******END******/
}

/*判断栈是否为空*/
bool SS_IsEmpty(SeqStack* ss)
{
	/*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
	return ss->top==-1;
    /******END******/
}

/*获取栈元素个数*/
int SS_Length(SeqStack* ss)
{
	/*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
	return ss->top+1;
    /******END******/
}

/*将x进栈,满栈则无法进栈(返回false)*/
bool SS_Push(SeqStack* ss, T x)
{
	/*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
	if(SS_IsFull(ss)) return false;
	else
	{
		ss->data[ss->top+1] = x;
		ss->top++;
	}
	return true;
    /******END******/
}

/*出栈，出栈的元素放入item,空栈则返回false*/
bool SS_Pop(SeqStack* ss, T &item)
{
	/*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
	if(SS_IsEmpty(ss)) return false;
	else{
		item = ss->data[ss->top];
		ss->top--;
	}

	return true;
    /******END******/
}

/*获取栈顶元素放入item中,空栈则返回false*/
bool SS_Top(SeqStack* ss, T & item)
{
	if (SS_IsEmpty(ss)) {
		return false;
	}
	item = ss->data[ss->top];
	return true;
}

/*从栈底到栈顶打印出所有元素*/
void SS_Print(SeqStack* ss)
{
	if (SS_IsEmpty(ss)) {
		printf("stack data: Empty!\n");
		return;
	}
	printf("stack data (from bottom to top):");
	int curr=0;
	while(curr<=ss->top) {
		printf(" %d", ss->data[curr]);
		curr++;
	}
	//printf("\n");
}

第2关：实现一个链接存储的栈

任务描述
本关任务是实现 step2/LnkStack.cpp 中的LS_IsEmpty、LS_Length、LS_Push、LS_Pop和LS_Top五个操作函数，以实现判断栈是否为空、求栈的长度、进栈、出栈以及获取栈顶元素等功能。

相关知识
链接存储的栈
栈的存储也可以采用链接存储的方式来实现。下面给出了一种基于链接存储的栈的实现方案：
在这里插入图片描述
如图 1 所示：该栈存储了 3 个元素 {56,77,15} ，其中 56 是栈顶元素。

这种实现方案中与栈相关的两个属性元素top和len介绍如下：

top: 指向栈顶结点的指针；
len: 栈中结点的个数。
特别说明：链接存储方式下，链表头结点作为栈顶结点，用指针top指向栈顶结点，栈结点个数由len给出。

基于top和len组织成的栈结构如下：

struct LinkStack {
LNode* top; // 栈顶指针
int len; // 栈的长度
};
为了讨论简单，我们假设栈元素的数据类型为整数：

typedef int T; // 栈元素的数据类型
同时，每个结点的结构定义为：

struct LNode {
T data;
LNode* next;
};
据此，只要给定指向该结构的一指针ls，就可对栈进行出栈操作。

进行出栈操作时，将指针top指向的当前栈顶元素 56 出栈，出栈后top指向下一个栈顶元素 77，这时的状态则如图 2 所示。

针对链式栈我们定义如下操作：

创建栈：创建一个链式栈。具体操作函数定义如下：
LinkStack* LS_Create()；

释放栈：释放栈所占用的空间。具体操作函数定义如下：
void LS_Free(LinkStack* ls)；

清空一个栈：将链式栈变为空栈。具体操作函数定义如下：
void LS_MakeEmpty(LinkStack* ls)；

判断栈是否为空：若栈为空，则返回true，否则返回false。具体操作函数定义如下：
bool LS_IsEmpty(LinkStack* ls)；

求栈的长度：获取链式栈的长度。具体操作函数定义如下：
int LS_Length(LinkStack* ls)；

将元素 x 进栈：将 x 进栈，若满栈则无法进栈，具体操作函数定义如下：
void LS_Push(LinkStack* ls, T x)；

出栈：出栈的元素放入 item 。若出栈成功(栈不为空)，则返回true；否则(空栈)，返回false。具体操作函数定义如下：
bool LS_Pop(LinkStack* ls, T& item)；

获取栈顶元素：获取栈顶元素放入 item 中。若获取失败(空栈)，则返回false，否则返回true。具体操作函数定义如下：
bool LS_Top(LinkStack* ls, T& item)；

打印栈中元素：从栈顶到栈底打印各结点数据元素。具体操作函数定义如下：
void LS_Print(LinkStack* ls)。

编程要求
本关任务是实现 step2/LnkStack.cpp 中的LS_IsEmpty、LS_Length、LS_Push、LS_Pop和LS_Top五个操作函数，以实现判断栈是否为空、求栈的长度、进栈、出栈以及获取栈顶元素等功能。具体要求如下：

LS_IsEmpty：判断栈是否为空，若栈为空，则返回true，否则返回false；

LS_Length：获取链式栈的长度；

LS_Push：将元素 x 进栈，若满栈则无法进栈，返回false，否则返回true；

LS_Pop：若出栈成功(栈不为空)，则返回true；否则(空栈)，返回false；

LS_Top：获取栈顶元素；

输入输出格式请参见后续说明及测试样例。

注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的五个操作函数时，在函数体内可调用其他操作。

本关涉及的代码文件 LnkStack.cpp 中的 5 个操作函数的代码框架如下：

bool LS_IsEmpty(LinkStack* ls)
// 判断栈是否为空。为空返回true，否则返回false。
{
// 请在这里补充代码，完成本关任务
/********** Begin /
/* End /
}
int LS_Length(LinkStack ls)
// 获取栈的长度
{
// 请在这里补充代码，完成本关任务
/* Begin /
/* End /
}
void LS_Push(LinkStack ls, T x)
// 将元素x进栈
{
// 请在这里补充代码，完成本关任务
/* Begin /
/* End /
}
bool LS_Pop(LinkStack ls, T& item)
// 出栈的元素放入item。若出栈成功(栈不为空)，则返回true；否则(空栈)，返回false。
{
// 请在这里补充代码，完成本关任务
/* Begin /
/* End /
}
bool LS_Top(LinkStack ls, T& item)
// 获取栈顶元素，若获取失败(空栈)，则返回false，否则返回true。
{
// 请在这里补充代码，完成本关任务
/* Begin /
/* End **********/
}
测试说明
本关的测试文件是 step2/Main.cpp ，负责对你实现的代码进行测试。具体代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include “LnkStack.h”
#pragma warning(disable:4996)
void main()
{
LinkStack* ls=LS_Create();
char dowhat[100];
while(true) {
scanf("%s", dowhat);
if (!strcmp(dowhat,“push”)) {
T x;
scanf("%d", &x);
LS_Push(ls,x);
}else if (!strcmp(dowhat,“pop”)) {
T item;
LS_Pop(ls, item);
}
else {
break;
}
}
int length=LS_Length(ls);
printf(“Stack length: %d\n”, length);
LS_Print(ls);
LS_Free(ls);
system(“PAUSE”);
}
注意：step2/Main.cpp 的代码不能被修改。

输入输出说明：
输入格式：
输入多个操作：如果输入 “push” ，则后面跟一个数 x ，表示 x 进栈；如果输入 “pop” ，表示出栈操作；如果输入 “end” ，表示输入结束。

输出格式：
输出栈的长度，然后从栈顶到栈底依次输出各元素。

以下是平台对step2/Main.cpp的测试样例：
样例输入:
push 56
push 15
push 12
push 13
pop
end
样例输出
Stack length: 3
The stack (from top to bottom): 12 15 56

AC代码

/*************************************************************
    date: June 2017
    copyright: Zhu En（祝恩）
    DO NOT distribute this code.
**************************************************************/
// 链接存储的栈实现文件

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

/*创建栈*/
LinkStack* LS_Create()
{
    LinkStack* ls=(LinkStack*)malloc(sizeof(LinkStack));
    ls->top = NULL;
    ls->len = 0;
    return ls;
}

/*释放栈*/
void LS_Free(LinkStack* ls)
{
    LNode* curr = ls->top;
    while(curr) {
        LNode* next = curr->next;
        free(curr);
        curr=next;
    }
    free(ls);
}

/*将栈变为空栈*/
void LS_MakeEmpty(LinkStack* ls)
{
    LNode* curr = ls->top;
    while(curr) {
        LNode* next = curr->next;
        free(curr);
        curr=next;
    }
    ls->top = NULL;
    ls->len = 0;
}

/*判断栈是否为空*/
bool LS_IsEmpty(LinkStack* ls)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    return ls->len==0;

    /********** End **********/
}

/*获取栈的长度*/
int LS_Length(LinkStack* ls)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/

    return ls->len;
    /********** End **********/
}

/*将x进栈*/
void LS_Push(LinkStack* ls, T x)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    LNode* p=(LNode*)malloc(sizeof(LNode));
    p->data = x;
    p->next = ls->top;
    ls->top = p;
    ls->len++;
    /********** End **********/
}

/*出栈。出栈元素放入item；如果空栈，将返回false*/
bool LS_Pop(LinkStack* ls, T& item)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    LNode* p = ls->top;
    if(p==NULL) return false;
    else
    {
        item = p->data;
        ls->top = p->next;
        ls->len--;
        free(p);
    }
    return true;
    /********** End **********/
}

/*读栈顶元素放入item。如果空栈，将返回false*/
bool LS_Top(LinkStack* ls, T& item)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(LS_IsEmpty(ls)) return false;
    item = ls->top->data;
    return true;
    /********** End **********/
}

/*从栈顶到栈底打印各结点数据*/
void LS_Print(LinkStack* ls)
{
    if (ls->len==0){ 
        printf("The stack: Empty!");
        return;
    }
    printf("The stack (from top to bottom):");
    LNode* curr=ls->top;
    while(curr) {
        printf(" %d", curr->data);
         
        curr=curr->next;
    }
   // printf("\n");
}
云yun云\^O^/
关注
  • 7
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
队列的顺序存储实现
weixin_45939792的博客
06-15 192
#define MaxSize<10> struct QNode { int Data[MaxSize]; int rear; int front; }; typedef struct QNode* Queue; //入队 void AddQ(Queue PtrQ, int item) { if ((PtrQ->rear + 1) % MaxSize == PtrQ->front) { printf("队列满"); return; } PtrQ->rea
循环队列操作的实现-顺序存储结构
文艺小青年儿
12-08 571
#include <iostream> #include <stdio.h> #define maxsize 50 using namespace std;//循环队列 typedef struct{ int data[maxsize]; int front,rear; }SqQueue;//初始化 void init(SqQueue &q){ q.front=q.rear=
educoder数据结构与算法 队列 第1关：实现一个顺序存储的队列
热门推荐
qq_54008392的博客
12-09 1万+
任务描述 本关任务：实现 step1/SeqQueue.cpp 中的SQ_IsEmpty、SQ_IsFull、SQ_Length、SQ_In和SQ_Out五个操作函数，以实现判断队列是否为空、是否为满、求队列长度、队列元素入队和出队等功能。 相关知识 队列是一个插入操作和删除操作受到限制的线性表数据结构。队列的插入和删除被限制在表的两端，即插入操作只能在表的一端进行，而删除操作只能在表的另一端进行，因此队列又称先进先出表。 顺序存储的队列 队列既可以采用顺序存储，也可以采用链接存储来实现。下面给出
educoder数据结构与算法 队列 第2关 实现一个链接存储的队列
qq_54008392的博客
12-11 8153
任务描述 本关任务：实现 step2/CLnkQueue.cpp 中的CLQ_IsEmpty、CLQ_Length、CLQ_In和CLQ_Out四个操作函数，以实现判断队列是否为空、求队列长度、队列元素入队和出队等功能。 相关知识 链式队列的定义 队列的存储除了顺序存储之外也可以采用链接存储方式来实现。图 1 描述了队列的一种链接存储实现方案。 该队列存储了 3 个元素 {56,77,15} ，其中 56 为队列头， 15 为队列尾。 这种实现方案中涉及到的两个属性元素如下： rear:
educoder数据结构与算法 栈 第1关：实现一个顺序存储的栈
qq_54008392的博客
12-11 1万+
任务描述 本关任务是实现 step1/SeqStack.cpp 中的SS_IsFull、SS_IsEmpty、SS_Length、SS_Push和SS_Pop五个操作函数，以实现判断栈是否为满、是否为空、求栈元素个数、进栈和出栈等功能。 相关知识 栈的基本概念 栈是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算，这一端被称为栈顶。栈既可以采用顺序存储，也可以采用链接存储来实现。下面给出了一种基于顺序存储的栈的实现方案： 如图 1 所示：该栈存储了 4 个元素 {56,77,1
数据结构-队列
localhost
04-16 528
#include <bits/stdc++.h> using namespace std; template<typename Type> class SeqQueue { public: SeqQueue(int sz) : rear(0), front(0), _count(0), maxSize(sz) { data = new Type[...
2.1实现一个顺序存储的线性表（educoder数据结构线性表实训题）
weixin_51575278的博客
07-26 9179
任务描述 本关任务：实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。 相关知识 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存储的线性表实现方案： 该方案将线性表存储在一片连续空间里，并通过data、len和max三个属性元素。组织成为一个结构： dat
Educoder头歌数据结构-队列基本运算的实现及其应用
qq_50848214的博客
11-05 9093
**头歌实践平台答案educoder ** 数据结构-队列基本运算的实现及其应用 第1关：顺序队列的实现 /************************************************************* date: January 2019 循环顺序队列 实现文件 **************************************************************/ void SQ_In(SqQueue *Q, ElemType e) /
队列的顺序存储与实现
07-29
1. **顺序存储结构**：在顺序存储结构中，队列的元素按照它们进入的顺序依次存储在一个固定大小的数组里。数组的前端表示队头，后端表示队尾。在实际应用中，我们需要知道队头和队尾的位置，以便进行正确的入队和出...
java队列实现方法(顺序队列,链式队列,循环队列)
08-28
Java 中可以使用 ArrayQueue 类来实现顺序队列。 ArrayQueue 类提供了多种构造方法，可以根据需要选择合适的构造方法来创建顺序队列。 ArrayQueue 类的方法包括： * size()：获取队列的大小 * offer()：添加元素...
顺序存储和链式存储的泛型队列_C语言项目
04-12
本项目专注于实现顺序存储和链式存储的泛型队列，使用C语言作为编程工具，旨在提供灵活且高效的操作接口。下面我们将深入探讨相关知识点。 首先，队列是一种先进先出（First In First Out, FIFO）的数据结构，它的...
C++ 数据结构实现两个栈实现一个队列
08-31
C++ 数据结构实现两个栈实现一个队列 在计算机科学中，队列是一种基本的数据结构，遵循先进先出（FIFO）的原则。然而，在某些情况下，使用两个栈来实现一个队列是一种常见的解决方案。这种方法可以减少空间复杂度，...
循环队列详解及队列的顺序表示和实现
08-31
代码中提供的实现使用了一个固定大小的数组来存储队列元素，适用于那些可以预知队列容量需求的情况。 总结来说，循环队列是为了解决顺序队列中的“假溢出”问题而设计的一种优化方案，它通过数组的循环使用提高了...
【数据结构】单链表的增删改查
最新发布
2302_78914800的博客
07-25 748
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
c语言（7.23）
fhgfyrsg的博客
07-23 621
【代码】c语言（7.23）
数据结构：（1）线性表
weixin_71751116的博客
07-24 1052
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
EXT4 数据结构
弥川的博客
07-25 338
结构 ext4_inode 实际使用的超出最初 128 字节 ext2 inode 的字节数记录在每个 inode 的 i_extra_isize 字段中，这使得结构 ext4_inode 可以在新内核中增长，而无需升级所有磁盘上的 inode。ext4 开始，flex_bg 中几个块组被捆绑在一起作为一个 逻辑块组，bitmap 空间和 inode Table 空间 flex_bg 的第一个块组被扩展为包括位图以及 flex_bg 中所有其他块组的 inode 表。没有 inode 0。
数据结构：数据类型与抽象数据类型
Weiki的博客
07-25 1189
数据结构：数据类型与抽象数据类型
实现一个顺序存储的队列
04-04
以下是使用Python语言实现一个顺序存储的队列的示例代码： ```python class Queue: def __init__(self, capacity): self.capacity = capacity self.queue = [None] * capacity self.front = 0 self.rear = -1 self.size = 0 def is_empty(self): return self.size == 0 def is_full(self): return self.size == self.capacity def enqueue(self, item): if self.is_full(): raise Exception("Queue is full") else: self.rear += 1 self.queue[self.rear] = item self.size += 1 def dequeue(self): if self.is_empty(): raise Exception("Queue is empty") else: item = self.queue[self.front] self.front += 1 self.size -= 1 return item def peek(self): if self.is_empty(): raise Exception("Queue is empty") else: return self.queue[self.front] def print_queue(self): print(self.queue) ``` 在上面的示例代码中，我们定义了一个`Queue`类，它具有以下方法： - `__init__(self, capacity)`：初始化队列，指定队列的最大容量。 - `is_empty(self)`：检查队列是否为空，如果是返回`True`，否则返回`False`。 - `is_full(self)`：检查队列是否已满，如果是返回`True`，否则返回`False`。 - `enqueue(self, item)`：将一个元素添加到队列的尾部。 - `dequeue(self)`：从队列的头部删除一个元素，并返回删除的元素。 - `peek(self)`：返回队列头部的元素，但不删除它。 - `print_queue(self)`：打印当前队列的元素。 在`__init__`函数中，我们创建一个静态列表，其大小为队列的最大容量。我们还定义了`front`和`rear`两个指针，它们分别指向队列的头部和尾部。在队列为空时，`front`指针指向队列的第一个元素，`rear`指针指向队列的最后一个元素。在队列中添加元素时，我们将`rear`指针向右移动一个位置，并将元素添加到其指向的位置。在从队列中删除元素时，我们将`front`指针向右移动一个位置，并返回其指向的元素。我们还定义了`size`变量来跟踪队列中元素的数量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值