队列的基本操作及其应用
队列的实现及应用原理是什么
队列的实现及应用原理是什么什么是队列队列是一种常见的数据结构，用于在先进先出（First-In-First-Out，FIFO）的原则下管理数据。
队列有两个基本操作：入队（enqueue）和出队（dequeue）。
队列的实现方式队列可以使用不同的实现方式，包括数组实现和链表实现。
数组实现在数组实现中，队列的元素被存储在连续的内存位置中。
可以通过使用两个指针front和rear来标识队列的起始和结束位置。
入队操作1.检查队列是否已满，如果满了则不能进行入队操作。
2.将元素添加到rear指向的位置。
3.将rear指针向后移动一位。
出队操作1.检查队列是否为空，如果为空则不能进行出队操作。
2.返回front指针指向的元素。
3.将front指针向后移动一位。
链表实现在链表实现中，每个元素包含了指向下一个元素的指针。
队列的头部和尾部可以通过指向链表的第一个和最后一个元素来确定。
入队操作1.创建一个新节点。
2.将新节点添加到链表的尾部。
3.更新队列尾部指针指向新节点。
出队操作1.检查队列是否为空，如果为空则不能进行出队操作。
2.返回队列头部的节点值。
3.更新队列头部指针指向下一个节点。
队列的应用场景队列的特点使其在很多应用中得到广泛应用。
以下是队列的一些常见应用场景。
操作系统中的任务调度操作系统中通常使用队列来调度任务。
每个任务加入队列时都会携带其优先级，任务调度器会按照优先级从高到低的顺序选择任务执行。
网络数据包传输网络中的数据包通常按照先后顺序进行传输。
数据包会被添加到发送队列中，然后按照先进先出的原则被发送出去。
广度优先搜索算法广度优先搜索算法（BFS）是一种常用的图遍历算法，它使用队列来管理待访问的节点。
每次从队列中取出一个节点，将其邻居节点加入队列，直到队列为空。
消息队列消息队列是一种常用的异步通信机制，用于将消息从发送者传递给接收者。
消息队列通常采用队列的形式进行数据传输。
缓冲区管理在缓冲区管理中，队列被用于临时存储数据。
实验二 栈和队列的基本操作实现及其应用
实验二栈和队列的基本操作实现及其应用一、实验目的1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。
2、会用栈和队列解决简单的实际问题。
二、实验内容（可任选或全做）题目一、试写一个算法，判断依次读入的一个以@为结束符的字符序列，是否为回文。
所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。
相关常量及结构定义：# define STACK_INIT_SIZE 100# define STACKINCREMENT 10# define OK 1# define ERROR 0typedef int SElemType;//栈类型定义typedef struct SqStack{ SElemType *base;SElemType *top;int stacksize;}SqStack;设计相关函数声明：判断函数：int IsReverse()栈：int InitStack(SqStack &S )int Push(SqStack &S, SElemType e )int Pop(SqStack &S,SElemType &e)int StackEmpty(s)题目二、编程模拟队列的管理，主要包括：出队列、入队、统计队列的长度、查找队列某个元素e、及输出队列中元素。
[实现提示]：参考教材循环队列的有关算法，其中后两个算法参考顺序表的实现。
题目三、RailsDescriptionThere is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited thattime. It was possible to establish only a surface track. Moreover, it turned out that the station could be only a dead-end one (see picture) and due to lack of available space it could have only one track.The local tradition is that every train arriving from the direction A continues in the direction B with coaches reorganized in some way. Assume that the train arriving from the direction A has N <= 1000 coaches numbered in increasing order 1, 2, ..., N. The chief for train reorganizations must know whether it is possible to marshal coaches continuing in the direction B so that their order will be a1, a2, ..., aN. Help him and write a program that decides whether it is possible to get the required order of coaches. You can assume that single coaches can be disconnected from the train before they enter the station and that they can move themselves until they are on the track in the direction B. You can also suppose that at any time there can be located as many coaches as necessary in the station. But once a coach has entered the station it cannot return to the track in the direction A and also once it has left the station in the direction B it cannot return back to the station.InputThe input consists of blocks of lines. Each block except the last describes one train and possibly more requirements for its reorganization. In the first line of the block there is the integer N described above. In each of the next lines of the block there is a permutation of 1, 2, ..., N. The last line of the block contains just 0.The last block consists of just one line containing 0.OutputThe output contains the lines corresponding to the lines with permutations in the input.A line of the output contains Yes if it is possible to marshal the coaches in the order required on the corresponding line of the input. Otherwise it contains No. In addition,there is one empty line after the lines corresponding to one block of the input. There is no line in the output corresponding to the last ``null'' block of the input. Sample Input51 2 3 4 55 4 1 2 366 5 4 3 2 1Sample OutputYesNoYes题目四、Sliding WindowDescriptionAn array of size n≤ 106 is given to you. There is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves rightwards by one position. Following is an example:The array is [1 3 -1 -3 5 3 6 7], and k is 3.Window position Minimum value Maximum value[1 3 -1] -3 5 3 6 7 -131 [3 -1 -3] 5 3 6 7 -331 3 [-1 -3 5] 3 6 7 -351 3 -1 [-3 5 3] 6 7 -351 3 -1 -3 [5 3 6] 7 361 3 -1 -3 5 [3 6 7]37Your task is to determine the maximum and minimum values in the sliding window at each position.InputThe input consists of two lines. The first line contains two integers n and k which are the lengths of the array and the sliding window. There are n integers in the second line.OutputThere are two lines in the output. The first line gives the minimum values in the window at each position, from left to right, respectively. The second line gives the maximum values.Sample Input8 31 3 -1 -3 5 3 6 7Sample Output-1 -3 -3 -3 3 33 3 5 5 6 7题目五（选作考查串知识）DNA Evolution【Description】Evolution is a seemingly random process which works in a way which resembles certain approaches we use to get approximate solutions to hard combinatorial problems. You are now to do something completely different.Given a DNA string S from the alphabet {A,C,G,T}, find the minimal number of copy operations needed to create another string T. You may reverse the strings you copy, and copy both from S and the pieces of your partial T. You may put these pieces together at any time. You may only copy contiguous parts of your partial T, and all copied strings must be used in your final T.Example: From S= “ACTG” create T= “GTACTAATAAT”1.Get GT......... by copying and reversing "TG" from S.2.Get GT AC... by copying "AC" from S.3.Get GTAC TA….. by copying "TA" from the partial T.4.Get GTACTA AT by copying and reversing "TA" from the partial T.5.Get GTACTAAT AAT by copying "AAT" from the partial T.【Input】The first line of input gives a single integer, 1 ≤k≤10, the number of test cases. Then follow, for each test case, a line with the string S , length of S is less then 19, and a line with the string T , length of T is less then 19.【Output】Output for each test case the number of copy operations needed to create T from S, or "impossible" if it cannot be done.【Sample Input】4ACGTTGCAACACGTTCGATCGAAAAAAAAAAAAAAAAAAAA【Sample output】1impossible46题目六（选作考查数组知识）Magic Squares描述Following the success of the magic cube, Mr. Rubik invented its planar version, called magic squares. This is a sheet composed of 8 equal-sized squares:1 2 3 48 7 6 5In this task we consider the version where each square has a different color. Colors are denoted by the first 8 positive integers. A sheet configuration is given by the sequence of colors obtained by reading the colors of the squares starting at the upper left corner and going in clockwise direction. For instance, the configuration of Figure 3 is given by the sequence (1,2,3,4,5,6,7,8). This configuration is the initial configuration.Three basic transformations, identified by the letters `A', `B' and `C', can be applied to a sheet:∙'A': exchange the top and bottom row,∙'B': single right circular shifting of the rectangle,∙'C': single clockwise rotation of the middle four squares.Below is a demonstration of applying the transformations to the initial squares given above:A:8 7 6 51 2 3 4B:4 1 2 35 8 7 6C:1 72 48 6 3 5All possible configurations are available using the three basic transformations.You are to write a program that computes a minimal sequence of basic transformations that transforms the initial configuration above to a specific target configuration.输入A single line with eight space-separated integers (a permutation of (1..8)) that are the target configuration.输出样例输入2 6 8 4 5 73 1样例输出7BCABCCB三、实验步骤㈠、数据结构与核心算法的设计描述㈡、函数调用及主函数设计（可用函数的调用关系图说明）㈢程序调试及运行结果分析㈣实验总结四、主要算法流程图及程序清单1、主要算法流程图：2、程序清单（程序过长，可附主要部分）//int IsReverse(){ ….while( (e=getchar())!='@'){e 依次入栈、入队 //push(S,e);EnQueue(Q,e);……..}While(!StackEmpty(S)) { pop(S,a);DeQueue(Q,b);If(a!=b) return 0;}return 1;}。
队列的实现及应用的实验原理是
队列的实现及应用的实验原理1. 实验目的本实验旨在通过分析队列的基本原理和应用，学习队列的实现方法及其在实际问题中的应用。
2. 队列的基本原理队列是一种先进先出（First-In-First-Out，FIFO）的数据结构，可以用线性表来实现。
队列有两个基本操作，即入队和出队。
2.1 入队操作入队操作是将一个元素添加到队列的末尾。
在队列中，新元素永远被追加到尾部。
如果队列已满，则无法执行入队操作。
2.2 出队操作出队操作是将队列首部的元素删除并返回。
在队列中，只有队首的元素才能被删除并返回。
如果队列为空，则无法执行出队操作。
3. 队列的实现方法队列可以通过数组或链表来实现。
下面分别介绍这两种实现方法。
3.1 数组实现数组实现队列时，需要定义两个指针，分别指向队首和队尾。
入队操作将元素添加到队尾，出队操作将队首元素删除并返回。
需要注意的是，当队尾指针到达数组末尾时，需要将队尾指针移到数组的起始位置。
优点•数组实现的队列在空间利用上比较高效。
•入队和出队操作的时间复杂度均为O(1)。
缺点•数组实现的队列在动态调整大小时比较困难。
•如果队列中存在大量删除操作，会导致存储空间的浪费。
3.2 链表实现链表实现队列时，可以使用单向链表或双向链表。
入队操作在链表尾部插入新的节点，出队操作删除链表头部节点。
优点•链表实现的队列在动态调整大小时比较灵活。
•链表实现的队列可以实现任意长度的队列。
缺点•链表实现的队列在空间利用上比较低效。
•入队和出队操作的时间复杂度均为O(1)。
4. 队列的应用队列在实际问题中有广泛的应用，下面介绍几个常见的应用场景。
4.1 任务调度队列可以用来实现任务调度，例如操作系统中的进程调度、网络中的消息调度等。
任务按照加入队列的顺序进行处理，保证了公平性和顺序性。
4.2 网络通信队列可以用来实现网络通信中的消息队列，用于存储待发送的消息和接收到的消息。
发送方将消息加入队列，接收方从队列中读取消息。
队列实验报告总结
队列实验报告总结队列实验报告总结引言：队列（Queue）是一种常用的数据结构，它按照先进先出（FIFO）的原则进行操作。
在本次实验中，我们通过实际操作和观察，深入了解了队列的特性和应用。
本文将对实验过程和结果进行总结和分析。
一、实验目的本次实验的目的是通过编写队列的相关操作代码，加深对队列数据结构的理解，并通过实际运行程序验证其正确性和效率。
同时，通过实验探索队列在现实生活中的应用场景。
二、实验过程1. 队列的基本操作我们首先实现了队列的基本操作，包括入队（enqueue）、出队（dequeue）、判空（isEmpty）和获取队首元素（front）等。
通过编写相应的代码，并在测试数据上进行验证，确保队列的基本操作正确无误。
2. 队列的应用场景在实验过程中，我们发现队列在现实生活中有许多应用场景。
例如，在银行排队叫号系统中，顾客按照先来先服务的原则排队等待办理业务；在操作系统中，进程调度也常使用队列来管理等待执行的任务。
通过这些实际例子，我们更加深入地理解了队列的实际应用。
三、实验结果通过对队列的基本操作进行测试，我们得出了以下实验结果：1. 队列的入队操作正常工作，能够将元素按照先后顺序加入队列。
2. 队列的出队操作也正常工作，能够按照先进先出的原则将元素从队列中取出。
3. 队列的判空操作能够正确判断队列是否为空。
4. 队列的获取队首元素操作能够返回队列中的第一个元素。
四、实验分析通过本次实验，我们对队列的特性和应用进行了深入了解。
队列的先进先出原则使得它在很多场景下都有着广泛的应用。
在实际编程中，队列常常用于解决问题中的先后顺序和依赖关系。
例如，在多线程编程中，任务的执行顺序可以通过队列来管理，保证每个任务按照特定的顺序执行。
此外，队列还可以用于缓冲区的实现。
在网络传输中，数据包的发送和接收往往存在速度不匹配的情况，通过使用队列作为缓冲区，可以实现数据的有序传输，保证数据的完整性和正确性。
同时，我们也发现队列的应用并不仅限于计算机领域，它在日常生活中也有着广泛的应用。
队列的建立及应用实验原理
队列的建立及应用实验原理1. 队列的概念队列是一种常见的数据结构，它按照先进先出（FIFO）的原则对元素进行操作。
在队列中，新元素总是从一端（称为队尾）添加，而从另一端（称为队头）删除，类似于现实生活中排队等候的场景。
2. 队列的基本操作队列的基本操作包括入队和出队操作。
其中，入队操作将一个元素插入到队列的队尾，出队操作将队头的元素移除。
队列的典型实现方式有两种：数组和链表。
2.1 数组实现队列1. 初始化一个空队列，包括设置队列的容量和队头、队尾指针。
2. 入队操作：- 判断队列是否已满，如果已满，则无法插入新元素；- 否则，将新元素插入到队尾，并更新队尾指针。
3. 出队操作：- 判断队列是否为空，如果为空，则无法执行出队操作；- 否则，将队头元素移除，并更新队头指针。
2.2 链表实现队列1. 初始化一个空队列，包括设置队头、队尾指针。
2. 入队操作：- 创建一个新的节点，并将新元素赋值给节点的值域；- 将新节点插入到链表的尾部，并更新队尾指针。
3. 出队操作：- 判断队列是否为空，如果为空，则无法执行出队操作；- 否则，移除链表头部的节点，并更新队头指针。
3. 队列的应用实验原理队列的应用非常广泛，在实际编程中常常用到。
以下是一些常见应用实验原理的列举：3.1 队列在多线程编程中的应用•多线程编程中，常常需要使用队列来实现线程间的同步与通信。
一个线程可以将数据放入队列中，另一个线程从队列中取出数据，从而实现线程间的数据传递。
•具体应用场景有消息队列、任务队列等。
3.2 队列在网络编程中的应用•在网络编程中，队列常用来处理客户端请求，将请求加入到队列中并进行排队。
这样可以保证请求按照先后顺序进行处理，避免数据混乱。
•具体应用场景有请求队列、消息队列等。
3.3 队列在操作系统中的应用•在操作系统中，队列被广泛应用于进程调度和页面置换等场景。
操作系统使用队列来管理进程的执行顺序，以及内存中页面的置换算法。
队列的应用实验报告
一、实验目的1. 理解队列的基本概念和特性，包括先进先出（FIFO）原则。
2. 掌握队列的基本操作，如初始化、入队、出队、判空、判满等。
3. 熟悉队列在实际问题中的应用，如操作系统中的进程调度、任务队列管理等。
4. 通过编程实现队列的应用，验证队列在实际问题中的有效性。
二、实验环境1. 编程语言：Python2. 开发工具：PyCharm3. 操作系统：Windows 10三、实验内容1. 队列的基本操作- 初始化队列：创建一个空队列，并设置队头指针（front）和队尾指针（rear）。
- 入队：将元素添加到队列的队尾。
- 出队：从队列的队头删除元素。
- 判空：判断队列是否为空。
- 判满：判断队列是否已满。
2. 队列的应用- 操作系统中的进程调度：使用队列模拟进程调度，将进程按照到达时间顺序入队，并根据CPU调度的策略进行出队。
- 任务队列管理：使用队列管理任务，将任务按照优先级或到达时间顺序入队，并根据任务处理的需要进行出队。
3. 编程实现- 使用Python实现队列的基本操作。
- 使用队列模拟操作系统中的进程调度。
- 使用队列管理任务队列。
四、实验步骤1. 队列的基本操作```pythonclass Queue:def __init__(self, capacity):self.capacity = capacityself.queue = [None] capacityself.front = 0self.rear = -1self.size = 0def is_empty(self):return self.size == 0def is_full(self):return self.size == self.capacitydef enqueue(self, item):if self.is_full():print("队列已满")returnself.rear = (self.rear + 1) % self.capacity self.queue[self.rear] = itemself.size += 1def dequeue(self):if self.is_empty():print("队列已空")return Noneitem = self.queue[self.front]self.front = (self.front + 1) % self.capacity self.size -= 1return itemdef peek(self):if self.is_empty():print("队列已空")return Nonereturn self.queue[self.front]```2. 操作系统中的进程调度```pythondef process_scheduling(queue):while not queue.is_empty():process = queue.dequeue()print(f"进程 {process} 正在执行")# 模拟进程执行time.sleep(1)```3. 任务队列管理```pythondef task_management(queue):while not queue.is_empty():task = queue.dequeue()print(f"任务 {task} 正在执行")# 模拟任务执行time.sleep(1)```五、实验结果与分析1. 队列的基本操作通过实验，验证了队列的基本操作的正确性，包括入队、出队、判空、判满等。
队列训练内容及流程
队列训练内容及流程队列是一种常见的数据结构，它具有先进先出（FIFO）的特点，常用于解决一些先来后到的问题。
队列的训练内容和流程可以分为以下几个部分：一、队列的基本操作队列的基本操作包括入队、出队、获取队首元素、获取队列长度等。
入队操作将一个元素加入队列的末尾，出队操作将队列的第一个元素移除并返回，获取队首元素操作返回队列的第一个元素但不移除，获取队列长度操作返回队列中元素的个数。
二、队列的应用队列的应用非常广泛，常见的应用场景包括：1. 线程池任务调度：将任务加入队列，线程池从队列中获取任务并执行。
2. 消息队列：将消息加入队列，消费者从队列中获取消息并处理。
3. 广度优先搜索算法：将起始节点加入队列，依次取出队首节点并将其邻居加入队列，直到找到目标节点。
三、队列的实现方式队列的实现方式有两种，一种是基于数组的顺序队列，另一种是基于链表的链式队列。
顺序队列的实现比较简单，但是需要预先分配一定大小的空间，当队列满时需要进行扩容操作；链式队列的实现相对复杂，但是可以动态地分配内存，不会出现扩容问题。
四、队列的优化队列的优化包括两个方面，一是空间优化，二是时间优化。
空间优化可以通过循环队列的方式来实现，避免了扩容操作；时间优化可以通过使用双端队列来实现，可以在队列两端进行插入和删除操作，提高了队列的效率。
队列训练的流程可以分为以下几个步骤：1. 学习队列的基本操作和应用场景。
2. 实现基于数组的顺序队列和基于链表的链式队列，并比较它们的优缺点。
3. 学习队列的优化方式，包括循环队列和双端队列。
4. 练习队列的应用，例如实现一个简单的消息队列或线程池任务调度系统。
5. 总结队列的使用场景和优化方式，掌握队列的使用技巧。
队列的基本操作及应用
循环队列的基本运算
（5）元素出队：
procedure delqueue(var Q:queue;var X:elemtype); begin if qempty(Q) then writeln(‘Underflow’) else begin Q.front:=(Q.front+1) mod maxsize; X:=Q.data[Q.front]; end; end;
最后根据队列sq中的存储信息和指针位 置，即可链接成从迷宫入口到出口的最短路 径。就上例而言，sq队列的最后情况为：
当rear指针指示的数据元素已到达出口 （6，8）时，根据rear所据元素的前趋序号 即可获得所要的走迷宫的最短路径（回溯）。
例题4：产生数（2002年NOIP普及组第3题） 给出一个整数n（n<2000）和k个变换规则（k≤15） 规则：① 1个数字可以变换成另1个数字； ② 规则中，右边的数字不能为零。 例如：n=234，k=2规则为 2 → 5 3 → 6 上面的整数234经过变换后可能产生出的整数为 （包括原数） 234 534 264 564 共4种不同的产生数 求经过任意次的变换（0次或多次），能产生出多 少个不同的整数。 仅要求输出不同整数个数。
（2）队列可以理解为一个数组，数组元素是如下记录： RECORD C10,C7,C3, pre: integer; END; 数组下标为容器状态号。下面是倒油过程的队列：
当倒油产生出第19个容器状态时已达到了题解的 目的。这时只要根据pre中的状态号17可以回溯到第 17个容器状态的pre值为15，依次可再获得13，11， 9，7，5，2，1容器状态号，从而即可得到本题的倒 油过程（共倒9次），而且是最少的倒油次数。
（1）从一个容器的状态（三个容器中油的 容量）看，虽然有可能经过上述六种倒油的 方法产生六种容器状态，但实际上这六种新 产生的容器状态，许多是已经出现过的状态。 例如初始状态（10,0,0）表示 C10=10， C7=0，C3=0，经过上述六种倒油方法只能产 生出两种新的容器状态（3,7,0），表示C10 向C7倒油的结果和（7,0,3），表示C10向C3 倒油的结果。如果再增加应该表示新容器状 态是由什么状态产生的指示pre，那么用这 三个容器倒油的过程就可以用队列的方法来 实现了。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
广西工学院计算机学院《数据结构》课程实验报告书实验四队列的基本操作及其应用学生姓名：李四学号：2012班级：计Y124指导老师：王日凤专业：计算机学院软件学院提交日期：2013年6月20日1．实验目的1）通过对队列特点的分析，掌握队列的存储结构及其基本操作，学会定义队列的顺序存储结构和链式存储结构，在实际问题中灵活运用。
2）掌握队列先进先出的特点，掌握队列的基本操作，如出队列、入队列、判队列空、判队列满等，熟悉各种操作的实现方法。
3）通过具体的应用实例，进一步熟悉和掌握队列的实际应用。
2.实验内容（1）建立一个含n个数据的队列，实现队列的基本操作。
包括：▪//1. 初始化,构造一个空队列void initQueue(Queue &Q)▪//2. 判断队列空, 空则返回truebool QueueEmpty(seqQueue &Q)▪//3. 判断队列满, 满则返回truebool QueueFull(seqQueue &Q)▪//4. 取队头元素, 用x返回队头元素，返回true；空队列则返回falseBool QueueHead(seqQueue &Q, elementType &x)▪//5. 入队列，在队尾插入新元素x （流程图）bool pushQueue (seqQueue &Q, elementType x)▪//6. 出队列，用x带回队头元素，并在队头删除，返回true，队列空则返回false（流程图）bool popQueue (seqQueue &Q, elementType &x)▪//7. 输出队列,从队头到队尾依次输出void printQueue(seqQueue Q)（2）队列应用：利用队列操作打印杨辉三角形的前n行（如n=7）。
3．实验要求（1）上机前交实验源程序（纸质版），由学习委员统一收好交老师（附上不交同学名单）。
（2）用一切你能想到的办法解决遇到的问题，培养解决问题的能力。
（3）实验课上进行答辩。
（4）实验报告当场交。
报告内容包括：实验目的、实验内容、实验代码、实验输入输出结果以及实验体会供五部分。
3．主要算法3.1 顺序存储结构（1）结构定义：#include<stdio.h>#include<stdlib.h>#include<malloc.h>#include<conio.h>//各个头文件#define OK 1#define ERROR 0#define OVERFLOW -2//定义宏参#define MAXQSIZE 100//最大队列长度typedef int QElemType;//引用整型数据类型别名//顺序表的储存结构typedef struct{QElemType *base;//初始化的动态分配内存空间int front;//头指针int rear;//尾指针}SqQueue;int N;//======================函数声明=========================// int InitQueue(SqQueue &Q);//初始化void creatQueue(SqQueue &Q,int n);//创建int QueueLength(SqQueue &Q);//求长度void EnQueue(SqQueue &Q,QElemType e);//入队int DeQueue(SqQueue &Q);//出队int QueueTraverse(SqQueue &Q);//显示队列int GetHead(SqQueue Q);//取头元素int DestroyQueue(SqQueue &Q);//销毁顺序表int ClearQueue(SqQueue &Q);//清空顺序表int yanghui(int n);//杨辉三角int ElemptyQueue(SqQueue &Q);//判空//======================函数声明=========================////构造空队列int InitQueue(SqQueue &Q){//操作结果：构造一个空队列Qprintf("输入分配空间大小: ");scanf(" %d",&N);Q.base=(QElemType *)malloc(N*sizeof(QElemType));//动态分配内存空间，以下同样if(!Q.base||N<0||N>MAXQSIZE){ //若n值不合理，则返回ERROR，以下同样printf("构造失败!");printf("\n\t\t按任意键返回主菜单!");getch();return ERROR;}Q.front=Q.rear=0;//队列设置为空，以下同样printf("构造成功!");printf("\n\t\t按任意键返回主菜单!");getch();return OK;}//初始化队列int InitQue(SqQueue &Q,int n){ //操作结果:初始化一个空队列Q.base=(QElemType *)malloc(n*sizeof(QElemType));if(!Q.base||n<0||n>MAXQSIZE)return ERROR;Q.front=Q.rear=0;return OK;}//创建队列void creatQueue(SqQueue &Q,int n){ //初始条件：Q已经存在//操作结果：向队列输入n个元素int m;if(!Q.base||n<0||n>N){printf("初始化未完成或超出队列长度，无法创建!");printf("\n\t\t按任意键返回主菜单!");getch();return;}printf("请输入入队元素!\n");for(int i=0;i<n;i++)//将元素逐个从队列尾部插入{printf("请输入第%d个数据：",i+1);scanf(" %d",&m);Q.rear=i;Q.base[Q.rear]=m;}Q.rear=(Q.rear+1)%N;//尾指针后移一位printf("创建成功!\n");QueueTraverse(Q);//调用显示函数printf("\n\t\t按任意键返回主菜单!");getch();return;}//求队列的长度int QueueLength(SqQueue &Q){ //初始条件：Q已经存在//操作结果：返回队列的长度QueueTraverse(Q);//调用显示函数printf("\nThe Queue length is: %d",(Q.rear-Q.front+N)%N);//打印表长printf("\n\n");printf("\n\t\t按任意键返回主菜单!");getch();return OK;}//入队列void EnQueue(SqQueue &Q,QElemType e){ //初始条件：Q已经存在//操作结果：插入元素e为Q的新的队尾元素if((Q.rear+1) % N==Q.front) //队列为满的情况{printf("队列已满,无法插入!");printf("\n\t\t按任意键返回主菜单!");getch();return;}Q.base[Q.rear]=e;Q.rear=(Q.rear+1) % N; //尾指针后移一位printf("入队成功!\n");QueueTraverse(Q);//调用显示函数printf("\n\t\t按任意键返回主菜单!");getch();return;}//入队列void EnQueu(SqQueue &Q,QElemType e){ //初始条件：Q已经存在//操作结果：插入元素e为Q的新的队尾元素if((Q.rear+1)%MAXQSIZE==Q.front)return;Q.base[Q.rear]=e;Q.rear=(Q.rear+1) % MAXQSIZE;}//出队列int DeQueue(SqQueue &Q){ //初始条件：Q已经存在//操作结果：若队列不空，删除Q的队头元素，//用e返回其值，并返回，否则返回int e;if(Q.front==Q.rear) //队列为空的情况{printf("队列为空，无法出队!");printf("\n\t\t按任意键返回主菜单!");getch();return ERROR;}e=Q.base[Q.front];Q.front=(Q.front+1) % N;//头指针后移一位printf("队头元素出队成功!\n");printf("这队头元素是：%d",e);printf("\n\t\t按任意键返回主菜单!");getch();return OK;}//出队列int DeQueu(SqQueue &Q){ //初始条件：Q已经存在//操作结果：若队列不空，删除Q的队头元素，//用e返回其值，并返回，否则返回int e;if(Q.front==Q.rear) //队列为空的情况return ERROR;e=Q.base[Q.front]; //将头元素赋给eQ.front=(Q.front+1) % MAXQSIZE;//头指针后移一位return e;}//显示int QueueTraverse(SqQueue &Q){ //初始条件：Q已经存在//操作结果：把队列中的元素输出到显示屏int i;i=Q.front;if(Q.front==Q.rear) //队列为空的情况{printf("The Queue is Empty!");printf("\n\t\t按任意键返回主菜单!");getch();return ERROR;}else{printf("The Queue is:");while(i!=Q.rear) //当队列不为空时{printf("%3d",Q.base[i]);i=(i+1)%N;}}printf("\n");printf("显示成功!");return OK;}//取队头元素int GetHead(SqQueue Q){ //初始条件：Q已经存在//操作结果：若队列不空，返回其值，否则返回int e;if(Q.front==Q.rear) //队列为空的情况{printf("The Queue is Empty!");printf("\n\t\t按任意键返回主菜单!");getch();return ERROR;}e=*(Q.base+Q.front);//将头元素赋给ereturn e;}//判断顺序表是否为空int ElemptyQueue(SqQueue &Q){ //初始条件：Q已经存在//操作结果：若队列为空返回，否则返回if(Q.front==Q.rear)//队列为空的情况return OK;elsereturn ERROR;}//销毁链表int DestroyQueue(SqQueue &Q){//初始条件:顺序表已存在//操作结果:销毁顺序表Q.front=Q.rear=0;return OK;}//清空队列int ClearQueue(SqQueue &Q){//初始条件:顺序表已存在//操作结果:清空顺序表Q.front=Q.rear=0;return OK;}//杨辉三角int yanghui(int n){ //打印输出杨辉三角的前n( n>0 )行if(n<0||n>MAXQSIZE){printf("行数不合理，无法显示!");printf("\n\t\t按任意键返回主菜单!");getch();return ERROR;}SqQueue Q;//定义新的循环队列int k,e,p;for(int i=1;i<=n;i++)printf(" ");printf("1\n");//在中心位置输出杨辉三角最顶端的"1"InitQue(Q,n+2);//设置最大容量为n+2 的空队列EnQueu(Q,0);//添加行界值EnQueu(Q,1);EnQueu(Q,1);//第一行的值入队列k=1;while(k<n){ //通过循环队列输出前n-1 行的值for(int i=1;i<=n-k;i++)printf(" ");//输出n-k个空格以保持三角型EnQueu(Q,0);//行界值"0"入队列do//输出第k 行，计算第k+1 行{p=DeQueu(Q);e=GetHead(Q);if(e)printf("%d ",e);//若e为非行界值，则打印输出e elseprintf("\n");//否则回车换行，为下一行输出做准备EnQueu(Q,p+e);}while(e!=0);k++;}e=DeQueu(Q);//行界值"0"出队列while(!ElemptyQueue(Q)){//单独处理第n 行的值的输出e=DeQueu(Q);printf("%d ",e);}printf("\n\t\t显示成功!");printf("\n\t\t按任意键返回主菜单!");getch();return OK;}//主函数void main(){SqQueue Q;//定义队列变量int b,c,f;//定义整型数据变量int j,k;//设置选项变量while(1){system("cls");//清屏printf("\n\t***************************************************"); printf("\n\t* 队列的基本操作及其应用 *");printf("\n\t***************************************************\n");printf("\t * 1.初始化队列 2.创建队列 *\n");printf("\t * 3.队列长度 4.入队队列 * \n");printf("\t * 5.取头元素 6.显示队列 * \n");printf("\t * 7.杨辉三角 8.销毁队列 * \n");printf("\t * 9.清空队列 0.退出 *\n");printf("\t****************************************************\n");printf("请选择选项<1-9>: ");//打印选项功能提示scanf(" %d",&k);if(k<0||k>9){printf("输入有误，请重新输入!");printf("\n");printf("\n\t\t\t按任意键进行重新操作!");getch();continue;}switch(k)//分支结构来调用各功能子函数{case 1:printf("创建空的循环队列\n");InitQueue(Q);//调用初始化函数printf("\n");break;//退出并重新进入主菜单case 2:printf("创建新的循环队列\n");printf("输入长度:");scanf("%d",&f);creatQueue(Q,f);//调用创建函数break;case 3:printf("求表长!\n");QueueLength(Q);//调用求表长函数break;case 4:printf("入队!\n");printf("输入入队元素: ");scanf("%d",&b);EnQueue(Q,b);//调用入队函数QueueTraverse(Q);//调用显示函数break;case 5:printf("出队!\n");DeQueue(Q);//调用出队函数break;case 6:printf("显示顺序表!\n");QueueTraverse(Q);//调用显示函数getch();break;case 7:system("cls");//清屏printf("杨辉三角!\n");printf("输入其行数: ");scanf(" %d",&c);//输入行数+1printf("杨辉三角显示为:\n");yanghui(c-1);//调用杨辉三角函数break;case 8:printf("你真确定要销毁队列! 1.YES 2.NO\n");printf("请选择项<1-2>: ");scanf("%d",&j);if(j==1)DestroyQueue(Q);printf("队列销毁成功呦!\n");if(j==2)printf("\n");printf("\n\t\t\t按任意键进行重新操作!");getch();break;case 9:printf("你真确定要清空队列! 1.YES 2.NO\n");printf("请选择项<1-2>: ");scanf("%d",&j);if(j==1){ClearQueue(Q);printf("队列清空成功呦!\n");}elseprintf("\n");printf("\n\t\t\t按任意键进行重新操作!");getch();break;case 0:printf("你真确定要退出! 1.YES 2.NO\n");printf("请选择项<1-2>: ");scanf("%d",&j);if(j==1){printf("\n\t\t\t再见，欢迎再次使用!\n\n\t\t\t");exit(OVERFLOW);}elseprintf("\n");printf("\n\t\t\t按任意键进行重新操作!");getch();break;}}}3.流程图如下1.队尾插入元素Q.front->Q.rear->1. 队尾插入元素2.删除队头元素4．程序运行结果（1）实验内容（1）运行结果如下：运行结果如下：运行结果如下：5.心得体会。