链队列

合集下载

计算链式队列平均值

计算链式队列平均值

计算链式队列平均值
链式队列是一种特殊的队列数据结构,其中的元素通过指针连接而形成链表。

计算链式队列的平均值涉及到遍历队列中的所有元素,并对它们的值进行求和,然后除以队列的长度即可得到平均值。

首先,我们需要了解链式队列的基本概念。

链式队列由节点组成,每个节点包
含数据和指向下一个节点的指针。

队列由头节点和尾节点来标识,头节点用于出队操作,尾节点用于入队操作。

在链式队列中,每个节点的值可以是任意类型的数据,例如整数、浮点数、字符串等。

计算链式队列的平均值的步骤如下:
1. 初始化链式队列和变量:首先,我们需要创建一个空的链式队列,并初始化
一个变量用于存储队列中所有元素的和,以及一个变量用于计算队列的长度。

2. 遍历队列并计算和与长度:从链式队列的头节点开始,依次遍历队列中的所
有节点。

在遍历的过程中,累加每个节点的值到和的变量中,并同时增加队列的长度计数器。

3. 计算平均值:将队列中所有元素的和除以队列的长度,即可得到链式队列的
平均值。

需要注意的是,计算链式队列的平均值的时间复杂度为O(n),其中n为队列的
长度。

这是因为需要遍历队列中的所有节点来计算和与长度。

总的来说,计算链式队列的平均值是一个简单的算法问题,只需要遍历队列中
的所有节点,并对其值进行累加和计数,最后进行平均值的计算即可。

在实际的程序开发中,可以根据具体的需求和数据类型进行相应的优化,以提高计算的效率。

链队列建立实验报告

链队列建立实验报告

#### 实验名称:链队列的建立与基本操作实现#### 实验者:[您的姓名]#### 实验日期:[实验日期]#### 实验环境:- 操作系统:[操作系统名称及版本]- 编程语言:C语言- 开发工具:[开发工具名称及版本]#### 实验目的:1. 理解链队列的数据结构和基本操作。

2. 掌握链队列的创建、插入、删除、遍历等基本操作。

3. 通过实际操作,加深对链式存储结构的理解。

#### 实验内容:#### 一、实验背景链队列是一种使用链表实现的队列,它结合了链表和队列的特点。

链队列中的每个元素(节点)都包含数据和指向下一个节点的指针,这样使得队列的插入和删除操作可以在常数时间内完成。

#### 二、实验步骤1. 定义链队列结构体:```ctypedef struct QueueNode {int data;struct QueueNode next;} QueueNode;typedef struct {QueueNode front; // 队头指针QueueNode rear; // 队尾指针} LinkQueue;```2. 初始化链队列:```cvoid InitQueue(LinkQueue Q) {Q->front = Q->rear = (QueueNode)malloc(sizeof(QueueNode)); if (!Q->front) exit(-1); // 内存分配失败Q->front->next = NULL;}```3. 入队操作:```cvoid EnQueue(LinkQueue Q, int x) {QueueNode s = (QueueNode)malloc(sizeof(QueueNode));if (!s) exit(-1); // 内存分配失败s->data = x;s->next = NULL;Q->rear->next = s;Q->rear = s;}```4. 出队操作:```cint DeQueue(LinkQueue Q) {if (Q->front == Q->rear) exit(-1); // 队列为空QueueNode p = Q->front->next;int x = p->data;Q->front->next = p->next;if (Q->rear == p) Q->rear = Q->front; // 队列变空 free(p);return x;}```5. 遍历队列:```cvoid TraverseQueue(LinkQueue Q) {QueueNode p = Q.front->next;while (p) {printf("%d ", p->data);p = p->next;}printf("\n");}```6. 销毁队列:```cvoid DestroyQueue(LinkQueue Q) {QueueNode p = Q->front;while (p) {QueueNode q = p;p = p->next;free(q);}Q->front = Q->rear = NULL;}```#### 三、实验结果与分析1. 初始化链队列:初始化链队列后,队头指针和队尾指针都指向同一个头结点,此时链队列为空。

数据结构(C语言)第3章 栈和队列

数据结构(C语言)第3章 栈和队列

Data Structure
2013-8-6
Page 13
栈的顺序存储(顺序栈)
利用一组地址连续的存储单元依次存放自栈底到栈顶的数 据元素。 结构定义: #define STACK_INIT_SIZE 100; // 存储空间初始分配量 #define STACKINCREMENT 10; // 存储空间分配增量 typedef struct { SElemType *base; // 存储空间基址 SElemType *top; // 栈顶指针 int stacksize; // 当前已分配的存储空间,以元素位单位 } SqStack;
解决方案2:
顺序栈单向延伸——使用一个数组来存储两个栈
Data Structure 2013-8-6 Page 21
两栈共享空间 两栈共享空间:使用一个数组来存储两个栈,让一个 栈的栈底为该数组的始端,另一个栈的栈底为该数组 的末端,两个栈从各自的端点向中间延伸。
Data Structure
2013-8-6
链栈需要加头结点吗? 链栈不需要附设头结点。
Data Structure
2013-8-6
Page 27
栈的链接存储结构及实现
Data Structure
2013-8-6
Page 11
GetTop(S, &e) 初始条件:栈 S 已存在且非空。 操作结果:用 e 返回S的栈顶元素。 Push(&S, e) 初始条件:栈 S 已存在。 操作结果:插入元素 e 为新的栈顶元素。 Pop(&S, &e) 初始条件:栈 S 已存在且非空。 操作结果:删除 S 的栈顶元素,并用 e 返回其值。
Data Structure

循环队列及链队列的基本操作 头歌

循环队列及链队列的基本操作 头歌

循环队列及链队列的基本操作1. 循环队列的基本概念和原理循环队列是一种常见的数据结构,它具有队列的特点,即先进先出(FIFO)。

与普通队列相比,循环队列的特点在于它可以充分利用数组的空间,解决了普通队列在出队操作时需要频繁搬移数据的问题。

循环队列的基本原理是使用环形数组来实现队列的存储和操作,通过头指针和尾指针的移动,实现队列的入队和出队操作。

2. 循环队列的基本操作2.1 入队操作:将元素插入队列的尾部,并更新尾指针的位置。

2.2 出队操作:从队列的头部取出元素,并更新头指针的位置。

2.3 判空操作:当头指针和尾指针重合时,队列为空。

2.4 判满操作:当尾指针的下一个位置与头指针重合时,队列为满。

3. 链队列的基本概念和原理链队列是另一种常见的队列实现方式,与循环队列不同的是,链队列使用链表来存储队列元素。

链队列的基本原理是使用链表的头节点和尾节点来实现队列的操作,通过指针的移动,实现入队和出队操作。

4. 链队列的基本操作4.1 入队操作:将元素插入队列的尾部,并更新尾节点的位置。

4.2 出队操作:从队列的头部取出元素,并更新头节点的位置。

4.3 判空操作:当头节点和尾节点指向同一个节点时,队列为空。

4.4 遍历操作:通过指针的遍历,可以获取队列中的所有元素。

5. 总结和回顾通过对循环队列和链队列的基本概念、原理和操作进行分析,我们可以看出它们都是用于实现队列功能的数据结构,但在不同的场景下有着不同的优势和应用。

循环队列适合于对空间有限且需要频繁进行入队和出队操作的场景,而链队列适合于对空间要求宽松、对操作有一定顺序要求的场景。

6. 个人观点和理解在实际编程中,循环队列和链队列都有着各自的优点和局限性,需要根据具体的场景和需求来选择合适的队列实现方式。

在使用循环队列时,需要注意头尾指针的移动,避免产生死循环和队列溢出的问题;而在使用链队列时,需要考虑对节点的动态分配和释放,避免产生内存泄漏和指针错乱的问题。

数据结构--栈和队列基础知识

数据结构--栈和队列基础知识

数据结构--栈和队列基础知识⼀概述栈和队列,严格意义上来说,也属于线性表,因为它们也都⽤于存储逻辑关系为 "⼀对⼀" 的数据,但由于它们⽐较特殊,因此将其单独作为⼀篇⽂章,做重点讲解。

既然栈和队列都属于线性表,根据线性表分为顺序表和链表的特点,栈也可分为顺序栈和链表,队列也分为顺序队列和链队列,这些内容都会在本章做详细讲解。

使⽤栈结构存储数据,讲究“先进后出”,即最先进栈的数据,最后出栈;使⽤队列存储数据,讲究 "先进先出",即最先进队列的数据,也最先出队列。

⼆栈2.1 栈的基本概念同顺序表和链表⼀样,栈也是⽤来存储逻辑关系为 "⼀对⼀" 数据的线性存储结构,如下图所⽰。

从上图我们看到,栈存储结构与之前所了解的线性存储结构有所差异,这缘于栈对数据 "存" 和 "取" 的过程有特殊的要求:1. 栈只能从表的⼀端存取数据,另⼀端是封闭的;2. 在栈中,⽆论是存数据还是取数据,都必须遵循"先进后出"的原则,即最先进栈的元素最后出栈。

拿图 1 的栈来说,从图中数据的存储状态可判断出,元素 1 是最先进的栈。

因此,当需要从栈中取出元素 1 时,根据"先进后出"的原则,需提前将元素 3 和元素 2 从栈中取出,然后才能成功取出元素 1。

因此,我们可以给栈下⼀个定义,即栈是⼀种只能从表的⼀端存取数据且遵循 "先进后出" 原则的线性存储结构。

通常,栈的开⼝端被称为栈顶;相应地,封⼝端被称为栈底。

因此,栈顶元素指的就是距离栈顶最近的元素,拿下图中的栈顶元素为元素 4;同理,栈底元素指的是位于栈最底部的元素,下中的栈底元素为元素 1。

2.2 进栈和出栈基于栈结构的特点,在实际应⽤中,通常只会对栈执⾏以下两种操作:向栈中添加元素,此过程被称为"进栈"(⼊栈或压栈);从栈中提取出指定元素,此过程被称为"出栈"(或弹栈);2.3 栈的具体实现栈是⼀种 "特殊" 的线性存储结构,因此栈的具体实现有以下两种⽅式:1. 顺序栈:采⽤顺序存储结构可以模拟栈存储数据的特点,从⽽实现栈存储结构。

《数据结构(C语言)》第3章 栈和队列

《数据结构(C语言)》第3章 栈和队列
Data structures

❖ 栈的顺序存储与操作 ❖ 1.顺序栈的定义
(1) 栈的静态分配顺序存储结构描述 ② top为整数且指向栈顶元素 当top为整数且指向栈顶元素时,栈空、入栈、栈满 及出栈的情况如图3.2所示。初始化条件为 S.top=-1。
(a) 栈空S.top==-1 (b) 元素入栈S.stack[++S.top]=e (c) 栈满S.top>=StackSize-1 (d) 元素出栈e=S.stack[S.top--]
/*栈顶指针,可以指向栈顶
元素的下一个位置或者指向栈顶元素*/
int StackSize; /*当前分配的栈可使用的以 元素为单位的最大存储容量*/
}SqStack;
/*顺序栈*/
Data structures

❖ 栈的顺序存储与操作 ❖ 1.顺序栈的定义
(2) 栈的动态分配顺序存储结构描述 ① top为指针且指向栈顶元素的下一个位置 当top为指针且指向栈顶元素的下一个位置时,栈空 、入栈、栈满及出栈的情况如图3.3所示。初始化条 件为S.top=S.base。
…,n-1,n≥0} 数据关系:R={< ai-1,ai>| ai-1,ai∈D,i=1,2
,…,n-1 } 约定an-1端为栈顶,a0端为栈底 基本操作:
(1) 初始化操作:InitStack(&S) 需要条件:栈S没有被创建过 操作结果:构建一个空的栈S (2) 销毁栈:DestroyStack(&S) 需要条件:栈S已经被创建 操作结果:清空栈S的所有值,释放栈S占用的内存空间
return 1;
}
Data structures

链队列的基本操作

链队列的基本操作
链队列是一种基于链表实现的队列,它具有链表的灵活性和队列的先进先出的特点。

链队列的基本操作包括初始化、入队、出队、判空和销毁等。

1. 初始化
链队列的初始化操作是创建一个空的链表作为队列的存储结构。

具体实现可以通过创建一个头结点来实现,头结点不存储任何数据,只是用来方便操作链表。

2. 入队
链队列的入队操作是在队列尾部插入一个新元素。

具体实现可以通过创建一个新的结点来实现,将新结点插入到队列尾部,并更新队列尾指针。

3. 出队
链队列的出队操作是从队列头部删除一个元素。

具体实现可以通过删除队列头部结点来实现,并更新队列头指针。

4. 判空
链队列的判空操作是判断队列是否为空。

具体实现可以通过判断队列头指针和队列尾指针是否相等来实现。

5. 销毁
链队列的销毁操作是释放队列占用的内存空间。

具体实现可以通过遍历整个链表,释放每个结点的内存空间来实现。

综上所述,链队列的基本操作包括初始化、入队、出队、判空和销毁等。

链队列的实现相对简单,但需要注意的是,在进行入队和出队操作时,需要更新队列头指针和队列尾指针,以保证队列的正确性。

同时,在进行销毁操作时,需要遍历整个链表,释放每个结点的内存空间,以避免内存泄漏的问题。

代码实现链式队列,输入数字入队,输入字符出队(c语言)

以下是使用C语言实现链式队列的代码,可以实现输入数字入队,输入字符出队的功能:#include <stdio.h>#include <stdlib.h>#include <string.h>// 定义链式队列结构体typedef struct QueueNode {int data; // 存储数字struct QueueNode* next; // 指向下一个节点} QueueNode;// 定义链式队列结构体typedef struct {QueueNode* front; // 指向队头节点QueueNode* rear; // 指向队尾节点} LinkedQueue;// 初始化链式队列void InitQueue(LinkedQueue* queue) {queue->front = NULL;queue->rear = NULL;}// 入队操作void EnQueue(LinkedQueue* queue, int data) {QueueNode* newNode =(QueueNode*)malloc(sizeof(QueueNode)); // 创建新节点newNode->data = data; // 将数字存储到新节点中newNode->next = NULL; // 新节点的下一个节点为空if (queue->rear == NULL) { // 如果队列为空,将新节点设置为队头和队尾queue->front = newNode;queue->rear = newNode;} else { // 如果队列不为空,将新节点添加到队尾,并更新队尾指针queue->rear->next = newNode;queue->rear = newNode;}}// 出队操作,返回出队的字符,如果队列为空,返回-1char DeQueue(LinkedQueue* queue) {if (queue->front == NULL) { // 如果队列为空,返回-1表示失败return -1;} else { // 如果队列不为空,将队头节点从队列中删除,并返回其存储的字符,同时更新队头指针char data = queue->front->data;QueueNode* temp = queue->front;queue->front = queue->front->next;free(temp); // 释放已删除节点的内存空间return data;}}。

DS博客作业02--栈和队列

DS博客作业02--栈和队列0.PTA得分截图1.本周学习总结(0-4分)1.1 总结栈和队列内容⼀.栈栈的定义栈是⼀种只能在⼀端进⾏插⼊或删除操作的线性表,俗称:后进先出。

表中允许进⾏插⼊、删除操作的⼀端称为栈顶。

栈的进栈出栈规则:1.栈顶出栈->栈底最后出栈;2.时进时出->元素未完全进栈时,即可出栈。

栈的分类:1.顺序栈利⽤⼀组地址连续的存储单元依次存放⾃栈底到栈顶的数据元素,同时附设指针 top 指⽰栈顶元素在顺序栈中的位置,附设指针 base 指⽰栈底的位置。

同样,应该采⽤可以动态增长存储容量的结构。

如果栈已经空了,再继续出栈操作,则发⽣元素下溢,如果栈满了,再继续⼊栈操作,则发⽣元素上溢。

栈底指针 base 初始为空,说明栈不存在,栈顶指针 top 初始指向 base,则说明栈空,元素⼊栈,则 top++,元素出栈,则 top--,故,栈顶指针指⽰的位置其实是栈顶元素的下⼀位(不是栈顶元素的位置)。

2.链栈其实就是链表的特殊情形,⼀个链表,带头结点,栈顶在表头,插⼊和删除(出栈和⼊栈)都在表头进⾏,也就是头插法建表和头删除元素的算法。

显然,链栈插⼊删除的效率较⾼,且能共享存储空间。

栈的基本运算InitStack(&s):初始化栈。

构造⼀个空栈s。

DestroyStack(&s):销毁栈。

释放栈s占⽤的存储空间。

StackEmpty(s):判断栈是否为空:若栈s为空,则返回真;否则返回假。

Push(&S,e):进栈。

将元素e插⼊到栈s中作为栈顶元素。

Pop(&s,&e):出栈。

从栈s中退出栈顶元素,并将其值赋给e。

GetTop(s,&e):取栈顶元素。

返回当前的栈顶元素,并将其值赋给e。

顺序栈的功能操作代码实现1.图像表⽰2.结构体定义typedef struct{ ElemType data[MaxSize];int top; //栈顶指针} Stack;typedef Stack *SqStack;3.基本运算<1>初始化栈initStack(&s)void InitStack(SqStack &s){ s=new Stack;s->top=-1;}<2>销毁栈ClearStack(&s)void DestroyStack(SqStack &s){ delete s;}<3>判断栈是否为空StackEmpty(s) bool StackEmpty(SqStack s){ return(s->top==-1);}<4>进栈Push(&s,e)bool Push(SqStack &s,ElemType e){ if (s->top==MaxSize-1)return false;s->top++; //栈顶指针增1s->data[s->top]=e;return true;}<5>出栈Pop(&s,&e)bool Pop(SqStack &s,ElemType &e){if (s->top==-1) //栈为空的情况,栈下溢出 return false;e=s->data[s->top];//取栈顶指针元素s->top--; //栈顶指针减1return true;}<6>取栈顶元素GetTop(s)bool GetTop(SqStack *s,ElemType &e) { if (s->top==-1) //栈为空的情况return false;e=s->data[s->top];return true;}4.顺序栈的四要素栈空条件:top=-1栈满条件:top=MaxSize-1进栈e操作:top++; st->data[top]=e 退栈操作:e=st->data[top]; top--;链栈的功能操作代码实现1.图像表⽰2.结构体定义typedef int ElemType;typedef struct linknode{ ElemType data; //数据域struct linknode *next; //指针域} LiNode,*LiStack3.基本运算<1>初始化栈initStack(&s)void InitStack(LiStack &s){ s=new LiNode;s->next=NULL;}<2>销毁栈ClearStack(&s)void DestroyStack(LiStack &s){ LiStack p;while (s!=NULL){ p=s;s=s->next;free(p);}}<3>判断栈是否为空StackEmpty(s)bool StackEmpty(LiStack s){return(s->next==NULL);}<4>进栈Push(&s,e)void Push(LiStack &s,ElemType e){ LiStack p;p=new LiNode;p->data=e; //新建元素e对应的节点*pp->next=s->next; //插⼊*p节点作为开始节点s->next=p;}<5>出栈Pop(&s,&e)bool Pop(LiStack &s,ElemType &e){ LiStack p;if (s->next==NULL) //栈空的情况return false;p=s->next; //p指向开始节点e=p->data;s->next=p->next; //删除*p节点free(p); //释放*p节点return true;}<6>取栈顶元素GetTop(s,e)bool GetTop(LiStack s,ElemType &e){ if (s->next==NULL) //栈空的情况return false;e=s->next->data;return true;}4.链栈的四要素栈空条件:s->next=NULL栈满条件:不考虑进栈e操作:结点插⼊到头结点后,链表头插法退栈操作:取出头结点之后结点的元素并删除之对于栈的C++模板类:stack#include<stack>1.stack<int> s:初始化栈,参数表⽰元素类型2.s.push(t):⼊栈元素t3.s.top():返回栈顶元素4.s.pop():出栈操作只是删除栈顶元素,并不返回该元素。

第3章数据结构基本类型3.3操作受限的线性表——队列-高中教学同步《信息技术-数据与数据结构》(教案

作业布置
编程实践:请实现一个循环队列,包含入队(enqueue)、出队(dequeue)、判断队列是否为空(is_empty)等基本操作。你可以使用Python语言进行编程,并编写相应的测试用例来验证你的实现。
理论思考:
思考并解释为什么队列的“先进先出”特性在现实生活中有广泛的应用。
假设你是一家大型超市的经理,你需要设计一个顾客结账排队系统。请说明你会如何利用队列的原理来设计一个既高效又公平的排队系统。
队列的应用:
结合日常生活中的排队场景,解释队列原理的实际应用,如银行取号系统、医院挂号系统等。
强调队列在处理具有“先来先服务”特性问题时的有效性,以及如何通过队列来优化服务流程。
教学难点
循环队列的实现与理解:
理解循环队列如何通过循环使用数组空间来避免“假溢出”现象。
掌握如何根据队列的头部和尾部指针判断队列的空和满状态。
完成后与同学交流并分享自己的解题思路和经验。
通过编程练习巩固所学知识,提高学生的编程能力和解决实际问题的能力。
鼓励学生互相交流和讨论,培养学生的团队协作能力和沟通能力。
课堂小结
作业布置
课堂小结
本节课我们深入学习了数据结构中的队列(Queue)这一重要概念。首先,通过日常生活中排队的例子,我们直观地理解了队列的基本特点——先进先出(FIFO),即新加入的元素总是排在队尾,而需要处理的元素总是从队头开始。
准备课后作业:设计一些与队列相关的课后作业,如编写顺序队列和链式队列的实现代码、分析队列在实际问题中的应用等,以巩固学生的学习效果。
教学媒体
教材或讲义:
提供了队列的基本概念、特征、实现方式以及应用实例的文字描述。
包含了队列的抽象数据类型定义、队列的存储结构(顺序队列、循环队列、链队列)等核心知识点的详细解释。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

链队列
#include<stdio.h>
#include<stdlib.h>
typedefintQElemType;
typedefstructQNode
{
QElemType data;//队列的数据类型
structQNode *next;//指向下一个结点
}QNode,*QueuePtr;
typedefstruct
{
QueuePtr front;//指向对头的指针
QueuePtr rear;//指向对尾的指针
}LinkQueue;
voidInitQueue(LinkQueue *q)
{ // 构造一个空队列Q
q->front=q->rear=malloc(sizeof(QNode));
if(!q->front)
exit(1);
q->front->next=NULL;
}
void EnQueue(LinkQueue *q, QElemType e)//将元素e进队{
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));//创建新节点
if(!p)//如果内存分配成功
exit(1);
p->data=e;//初始化新节点数据为e
p->next=NULL;
q->rear->next=p;
q->rear=p;
}
intDeQueue(LinkQueue *q,QElemType e)//队头结点出队,将出队的元素存入e {
QueuePtr p;
if(q->front==q->rear)//队列为空
return 0;
p=q->front->next;//初始化temp为要出队的结点指针
if(q->front->next==q->rear)//要出队的结点为最后一个结点
q->rear=q->front;
e=p->data;//要出队的数据元素为e
q->front->next=p->next;//使下一个结点变为对头
free(p);//删除要出队的结点
return e;
}
void QueueLength(LinkQueue *q)//返回队列长度
{
QueuePtr p;
int i=0;
p=q->front->next;
while(p)
{
++i;
p=p->next;
}
printf("链队列长度为:%d\n",i);
}
void DestroyQueue(LinkQueue *q)
{
while(q->front)
{
q->rear=q->front->next;
free(q->front);
q->front=q->rear;
if(!q->rear)
free(q->rear);
}
free(q->front);
}
void output(LinkQueue *q)//输出队列
{
QueuePtr p;
p=q->front->next;
printf("链队列元素依次为:");
while(p)
{
printf("%d->",p->data);
p=p->next;
}
printf("\n");
}
void Clear(LinkQueue *q)//清空队列
{
QueuePtr temp=q->front->next;
while(temp)
{
QueuePtrtp=temp;
temp=temp->next;
free(tp);
}
temp=q->front;
q->front=q->rear=NULL;
free(temp);
}
intGetHead(LinkQueue *q, int *e)//返回对头结点元素,存入e {
if(q->front==q->rear)
return 0;
*e=q->front->next->data;
return 1;
}
void start()
{
system("color 0D");//字体颜色
printf(" \n"); printf(" 欢迎来到链对列\n");
printf(" ********************************\n");
printf(" 1--------输出队列长度\n");
printf(" 2--------元素入队\n");
printf(" 3--------元素出队\n");
printf(" 4--------销毁队列\n");
printf(" 5--------清空队列\n");
printf(" 6--------对头元素\n");
printf(" 0--------退出顺序对列\n");
printf(" *********************************\n"); printf(" 请选择操作(0--5):");
}
/*0 = 黑色8 = 灰色
1 = 蓝色9 = 淡蓝色
2 = 绿色 A = 淡绿色
3 = 湖蓝色 B = 淡浅绿色
4 = 红色 C = 淡红色
5 = 紫色 D = 淡紫色
6 = 黄色 E = 淡黄色
7 = 白色 F = 亮白色*/
void main()
{
LinkQueue q;
int a;
inte,i,n,s;
InitQueue(&q);
printf("创建队列完成!\n");
printf("输入将建立链队列元素的个数:n=");
scanf("%d",&n);
printf("请输入队列的元素:\n");
for(i=1;i<=n;i++)
{
printf("请输入第%d个元素:",i);
scanf("%d",&e);
EnQueue(&q,e);
}
a=-1;
start();
while(a!=0)
{
scanf("%d",&a);
switch(a)
{
case 1:system("cls");
QueueLength(&q);
a=-1;
start();
break;
case 2:{
system("cls");
printf("请输入入队元素:");
scanf("%d",&e);
EnQueue(&q,e);
output(&q);
a=-1;
start();
}break;
case 3:
system("cls");
e=DeQueue(&q,e);
output(&q);
printf("出队元素为:%d\n",e);
a=-1;
start();
break;
case 4:DestroyQueue(&q);
printf("队列已销毁!\n");
a=0;
break;
case 5:
Clear(&q);
printf("队列已清空");
a=0;
break;
case 6:
system("cls");
GetHead(&q,&e);
printf("队头元素为:%d\n",e);
s=-1;
start();
break;
case 0:
break;
}
}
}。

相关文档
最新文档