链队列基本操作的C++实现

合集下载

链队列建立实验报告

#### 实验名称：链队列的建立与基本操作实现#### 实验者：[您的姓名]#### 实验日期：[实验日期]#### 实验环境：- 操作系统：[操作系统名称及版本]- 编程语言：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. 初始化链队列：初始化链队列后，队头指针和队尾指针都指向同一个头结点，此时链队列为空。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构(c语言版)课后习题答案完整版

数据结构(c语言版)课后习题答案完整版数据结构(C语言版)课后习题答案完整版一、数据结构概述数据结构是计算机科学中一个重要的概念，用来组织和存储数据，使之可以高效地访问和操作。

在C语言中，我们可以使用不同的数据结构来解决各种问题。

本文将提供完整版本的C语言数据结构的课后习题答案。

二、顺序表1. 顺序表的定义和基本操作顺序表是一种线性表，其中的元素在物理内存中连续地存储。

在C 语言中，我们可以通过定义结构体和使用指针来实现顺序表。

以下是顺序表的一些基本操作的答案：（1）初始化顺序表```ctypedef struct{int data[MAX_SIZE];int length;} SeqList;void InitList(SeqList *L){L->length = 0;}```（2）插入元素到顺序表中```cbool Insert(SeqList *L, int pos, int elem){if(L->length == MAX_SIZE){return false; // 顺序表已满}if(pos < 1 || pos > L->length + 1){return false; // 位置不合法}for(int i = L->length; i >= pos; i--){L->data[i] = L->data[i-1]; // 向后移动元素 }L->data[pos-1] = elem;L->length++;return true;}```（3）删除顺序表中的元素```cbool Delete(SeqList *L, int pos){if(pos < 1 || pos > L->length){return false; // 位置不合法}for(int i = pos; i < L->length; i++){L->data[i-1] = L->data[i]; // 向前移动元素 }L->length--;return true;}```（4）查找顺序表中的元素```cint Search(SeqList L, int elem){for(int i = 0; i < L.length; i++){if(L.data[i] == elem){return i + 1; // 找到元素，返回位置 }}return -1; // 未找到元素}```2. 顺序表习题解答（1）逆置顺序表```cvoid Reverse(SeqList *L){for(int i = 0; i < L->length / 2; i++){int temp = L->data[i];L->data[i] = L->data[L->length - 1 - i]; L->data[L->length - 1 - i] = temp;}}```（2）顺序表元素去重```cvoid RemoveDuplicates(SeqList *L){for(int i = 0; i < L->length; i++){for(int j = i + 1; j < L->length; j++){if(L->data[i] == L->data[j]){Delete(L, j + 1);j--;}}}}```三、链表1. 单链表单链表是一种常见的链式存储结构，每个节点包含数据和指向下一个节点的指针。

数据结构课程标准

数据结构课程标准课程目标1：理解线性表、栈和队列、串、树和二叉树和图的逻辑结构，掌握在各种逻辑结构上的各种基本操作的实现，培养学生进行复杂程序设计的能力和数据抽象的能力。

课程目标2：熟练掌握常用的静态查找和动态查找算法，深刻理解排序的定义和各种排序方法的特点，并能加以灵活应用。

课程目标3：能够从时间和空间复杂性的角度综合比较各种算法的复杂度，并能分析顺序存储和链式存储两种常用存储结构的不同特点及适用场合。

三、课程目标与毕业要求的关系1、课程目标与毕业要求的对应关系课程目标2课程目标3注：H表示高支撑，M表示中支撑，1表示低支撑。

参考《数学学院课程目标达成度评价方法》进行评价。

九、本课程各个课程目标的权重依据第八部分中的课程目标达成度评价方法，计算得到本课程的各个课程目标的权重如下:根据学生的课堂表现、作业、平时测验和期末考试情况及教学督导的反馈，检验学生对本课程涉及的学科素养和学会反思的达成情况，及时对教学中的不足之处进行改进，调整教学指导策略；根据学生的课堂表现、作业、平时测验及期末考试成绩，检验本课程所支撑的毕业要求分解指标点的达成度情况;根据本课程所支撑的毕业要求分解指标点的达成度情况，在本学院教学指导委员会指导下，重新修订本课程大纲，实现持续改进。

十一、推荐教材及参考书目1.教材1.孙丽云.数据结构（C语言版）[M].武汉：华中科技大学出版社,2017.2.参考书目2.孙丽云.数据结构实验指导与习题解析（C语言版）[M].北京：华中科技大学出版社,2017.3.严蔚敏，吴伟民.数据结构（C语言版）[M].北京：清华大学出版社，2012.4.高一凡，数据结构算法解析[M].北京：清华大学出版社，2015.。

链队列的基本操作

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

c++中队列的用法

c++中队列的用法队列是一种先进先出（FIFO）的数据结构，它按照元素添加和移除元素的顺序访问元素。

在C语言中，可以使用数组来实现队列。

队列有两个主要的操作：入队（添加元素到队尾）和出队（从队头移除元素）。

一、队列的基本操作在C中，队列通常使用数组来实现。

以下是一些基本的队列操作：1.初始化队列可以使用以下代码来初始化一个空的队列：```cqueue*q=(queue*)malloc(sizeof(int));//初始化一个空的整数队列```2.入队操作入队操作是将元素添加到队列的末尾。

可以使用以下代码来实现：```cq->data[q->head]=x;//将元素x添加到队列的头部q->head=(q->head+1)%MAXSIZE;//将头部指针移动到下一个位置```其中，`MAXSIZE`是队列的最大大小，`data`是队列的数组，`head`是队列的头部指针。

3.出队操作出队操作是从队列的头部移除元素。

可以使用以下代码来实现：```cif(q->tail!=q->head){//如果队列中还有元素x=q->data[q->head];//移除头部元素并保存它q->head=(q->head+1)%MAXSIZE;//将头部指针移动到下一个位置}else{//如果队列为空，则不能执行出队操作x=NULL;//返回一个无效的值来表示队列为空}```其中，`tail`是队列的尾部指针。

二、队列的应用场景队列是一种非常有用的数据结构，它适用于多种场景。

以下是一些常见的队列应用场景：1.任务调度：队列可以用于任务调度，将待执行的任务按照优先级添加到队列中，然后按照优先级顺序从队列中取出任务并执行。

这样可以确保高优先级任务能够优先执行，避免低优先级任务阻塞高优先级任务的执行。

2.生产者-消费者问题：队列可以用于解决生产者-消费者问题。

生产者将数据添加到队列中，消费者从队列中取出数据并处理它们。

代码实现链式队列,输入数字入队,输入字符出队(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;}}。

实验二堆栈和队列基本操作的编程实现

HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY
数据结构
实验报告
实验二堆栈和队列基本操作的编程实现
【实验目的】
堆栈和队列基本操作的编程实现
要求：
堆栈和队列基本操作的编程实现（2学时，验证型），掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】
验证性实验（学时数：2H）
【实验内容】
内容：把堆栈和队列的顺序存储（环队）和链表存储的数据进队、出队等运算其中一部分进行程序实现。

可以实验一的结果自己实现数据输入、数据显示的函数。

利用基本功能实现各类应用，如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。

【注意事项】
1.开发语言：使用C。

2.可以自己增加其他功能。

【实验分析、说明过程】
【思考问题】
【实验小结】 (总结本次实验的重难点及心得、体会、收获)。

数据结构(c语言版)第三版习题解答

数据结构(c语言版)第三版习题解答数据结构（C语言版）第三版习题解答1. 栈(Stack)1.1 栈的基本操作栈是一种具有特定限制的线性表，它只允许在表的一端进行插入和删除操作。

栈的基本操作有：（1）初始化栈（2）判断栈是否为空（3）将元素入栈（4）将栈顶元素出栈（5）获取栈顶元素但不出栈1.2 栈的实现栈可以使用数组或链表来实现。

以数组为例，声明一个栈结构如下：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储栈中的元素int top; // 栈顶指针} Stack;```1.3 栈的应用栈在计算机科学中有广泛的应用，例如计算表达式的值、实现函数调用等。

下面是一些常见的栈应用：（1）括号匹配：使用栈可以检查一个表达式中的括号是否匹配。

（2）中缀表达式转后缀表达式：栈可以帮助我们将中缀表达式转换为后缀表达式，便于计算。

（3）计算后缀表达式：使用栈可以方便地计算后缀表达式的值。

2. 队列(Queue)2.1 队列的基本操作队列是一种按照先进先出（FIFO）原则的线性表，常用的操作有：（1）初始化队列（2）判断队列是否为空（3）将元素入队（4）将队头元素出队（5）获取队头元素但不出队2.2 队列的实现队列的实现一般有循环数组和链表两种方式。

以循环数组为例，声明一个队列结构如下：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储队列中的元素int front; // 队头指针int rear; // 队尾指针} Queue;```2.3 队列的应用队列在计算机科学中也有广泛的应用，例如多线程任务调度、缓存管理等。

下面是一些常见的队列应用：（1）广度优先搜索：使用队列可以方便地实现广度优先搜索算法，用于解决图和树的遍历问题。

（2）生产者-消费者模型：队列可以用于实现生产者和消费者之间的数据传输，提高系统的并发性能。

c++ 队列的编程题目

c++ 队列的编程题目队列是一种具有先进先出特性的数据结构，在编程中有着广泛的应用。

下面是一些关于队列的编程题目，供大家参考和学习。

1. 实现队列的基本操作题目描述：要求实现一个基本的队列数据结构，包括入队（enqueue）、出队（dequeue）、检查队首元素等基本操作。

可以使用数组或链表来实现队列。

解题思路：队列是一种先进先出数据结构，可以使用循环数组或链表来存储元素。

入队操作可以在尾部添加元素，出队操作可以从头部删除元素。

检查队首元素可以使用一个变量来记录队首元素的位置。

代码实现：```c#include <stdio.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int front; // 队首元素的位置int rear; // 队尾元素的下一个位置} Queue;void init(Queue *q) {q->front = 0;q->rear = -1;}int is_empty(Queue *q) {return q->rear == -1;}int is_full(Queue *q) {return (q->rear + 1) % MAX_SIZE == q->front; }void enqueue(Queue *q, int value) {if (is_full(q)) {printf("Queue is full!\n");return;}q->rear = (q->rear + 1) % MAX_SIZE;q->data[q->rear] = value;}int dequeue(Queue *表示队列为空的返回值}int value = q->data[q->front];q->front = (q->front + 1) % MAX_SIZE;return value;}```2. 队列的应用场景及优化方案队列在编程中有着广泛的应用，例如在操作系统中用于实现进程调度、在编译器中用于实现语法分析等。

队列的c语言程序

队列的c语言程序队列的C语言程序队列是计算机科学中非常重要的数据结构之一，它可以用来实现各种算法。

在C语言中，队列可以使用指针和数组两种方式进行实现。

本文将介绍这两种实现方法。

数组实现队列数组实现队列的基本思想是：定义一个数组来保存队列中的元素，并通过两个指针front和rear来表示队首和队尾。

front指向队列的第一个元素，rear指向队列的最后一个元素。

入队操作时，将元素添加到队尾并将rear指针向后移动一位；出队操作时，将队首元素的值返回并将front指针向后移动一位。

下面是一个简单的数组实现队列的C语言代码：```#define MAXSIZE 100 // 队列的最大长度int queue[MAXSIZE]; // 队列数组int front = 0; // 队首指针int rear = 0; // 队尾指针// 判断队列是否为空int is_empty() {return front == rear;}// 判断队列是否已满int is_full() {return rear == MAXSIZE;}// 入队操作void enqueue(int item) {if (is_full()) {printf("Queue is full!\n"); return;}queue[rear++] = item;}// 出队操作int dequeue() {if (is_empty()) {printf("Queue is empty!\n"); return -1;}int item = queue[front++];return item;}```指针实现队列指针实现队列的基本思想是：定义一个链表来保存队列中的元素，并通过两个指针head和tail来表示队首和队尾。

head指向队列的第一个元素，tail指向队列的最后一个元素。

入队操作时，将元素添加到队尾，并更新tail指针；出队操作时，将队首元素的值返回并更新head指针。

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

头歌循环队列及链队列的基本操作
头歌循环队列及链队列是两种不同的队列实现方式。

下面是它们的基本操作：
1. 头歌循环队列的基本操作：
初始化队列：创建一个循环队列，设置头指针和尾指针为-1。

入队操作：向队列中插入一个元素，将尾指针加1，如果尾指
针等于队列长度，则将尾指针置为0，队列满则插入失败。

出队操作：删除队列中的一个元素，将头指针加1，如果头指
针等于队列长度，则将头指针置为0，队列空则删除失败。

判空操作：如果头指针等于尾指针，且头指针不等于-1，则队
列为空。

判满操作：如果尾指针加1等于头指针，则队列满。

2. 链队列的基本操作：
初始化队列：创建一个链队列，设置头指针和尾指针为NULL。

入队操作：向队列中插入一个元素，创建一个结点，将元素存入结点的数据域，让尾指针指向该结点，如果队列为空，则头指针也指向该结点。

出队操作：删除队列中的一个元素，将头指针指向下一个结点，
如果队列为空，则删除失败。

判空操作：如果头指针和尾指针都为NULL，则队列为空。

判满操作：链队列不会满，因为内存动态分配，只要内存不满就可以一直入队。

以上就是头歌循环队列及链队列的基本操作。

链队的基本操作

链队的基本操作//1、设置程序的环境，将下列环境设置代码补充完整。

#include "stdio.h"#include "string.h"#define OK 1#define ERROR 0typedef int status;typedef struct stu{ //添加图书信息结构char no[20]; //学号char name[50]; //姓名float score; //成绩}stu;typedef struct QNode{ /* 定义链队列的结点结构类型 */stu data;struct QNode *next;}QNode,*QueuePtr;typedef struct { /* 定义队列的链式表⽰结构类型 */QueuePtr front;QueuePtr rear;}LinkQueue; //定义链队列类型变量status initQueue(LinkQueue &Q){Q.front=Q.rear=new QNode;Q.front->next=NULL;return OK;}//3、在第1和第2题的基础上，编写⼊队函数、出队函数。

/* 图书数据⼊队 */status append(LinkQueue &Q){ QNode *p;p=new QNode;printf("输⼊学号 no=?");scanf("%s",&p->data.no);printf("输⼊姓名 name=?");scanf("%s",p->);printf("输⼊成绩 score?");scanf("%f",&p->data.score);p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}/* 出队*/status Qdelete(LinkQueue &Q,stu &e){ QNode *p;if(Q.front==Q.rear) return ERROR;p=Q.front->next;strcpy(e.no,p->data.no ); //将出队元素值保存到estrcpy(,p->);e.score=p->data.score;Q.front->next=p->next;if(Q.rear==p) Q.rear=Q.front;delete p;return OK;}change(LinkQueue &Q,stu e){QNode *p;if(Q.front==Q.rear) return ERROR;p=Q.front->next;while(p){if(strcmp(p->,)==0){printf("find!");p->data.score=e.score;return OK;}p=p->next;}return ERROR;}//4、输⼊显⽰队列元素的函数display ( )。

数据结构-使用C语言朱战立第3章堆栈和队列

top
D top C B A
D C B A
top
D C B A
top
顺序栈出栈函数的核心语句： S->top --; d = S->stack[S->top];
17
例5、设依次进入一个栈的元素序列为c，a，b，d，则可得到出栈的元素序列是：
Ａ）a，b，c，d Ｃ）b，c，d，a
Ｂ）c，d，a，b Ｄ）a，c，d，b
初始化堆栈S 堆栈S非空否入栈出栈取栈顶数据元素
11
二、堆栈的顺序表示和实现 1、顺序（堆）栈
顺序存储结构的堆栈。
顺序栈S an an-1 …… 栈顶top
2、顺序栈的存储结构
它是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时设指针top指示当前栈顶位置。
ai …… a1 a0
具体方法：顺序扫描算术表达式（表现为一个字符串），当遇到三种类型的左括号时让该括号进栈； 1. 当扫描到某一种类型的右括号时，比较当前栈顶括号是否与之匹配，若匹配则退栈继续进行判断； 2. 若当前栈顶括号与当前扫描的括号不相同，则左右括号配对次序不正确； 3. 若字符串当前为某种类型左括号而堆栈已空，则右括号多于左括号； 4. 字符串循环扫描结束时，若堆栈非空（即堆栈中尚有某种类型左括号），则说明左括号多于右括号；否则，左右括号匹配正确。
14
顺序栈S
高地址
栈顶top
an an-1 …… ai …… a1 a0 入栈口诀：堆栈指针top “先压后加” : S[top++]=an 栈底base 出栈口诀：堆栈指针top “先减后弹” : e=S[--top]
低地址
栈不存在的条件： base=NULL; 栈为空的条件： base=top或top<=0；栈满的条件： top-base=MaxSize;

队列的基本操作(c语言版)

#include<stdio.h>#include<stdlib.h>typedef int elemType;struct QueuePtr{elemType data;struct QueuePtr *next;};struct LinkQueue{struct QueuePtr *front;struct QueuePtr *rear;};void initQueue(struct LinkQueue *Q)/*第一个操作构造一个空队列q*/{Q->front = Q->rear = NULL;/* 把队首和队尾指针置空*/return;}void push(struct LinkQueue *Q, elemType x)/*第二个操作插入元素e为q的新的队尾元素*/{/* 得到一个由newP指针所指向的新结点*/struct QueuePtr *newP;newP = (struct QueuePtr*)malloc(sizeof(struct QueuePtr));if(newP == NULL){printf("内存空间分配失败！");exit(1);}/* 把x的值赋给新结点的值域，把新结点的指针域置空*/newP->data = x;newP->next = NULL;/* 若链队为空，则新结点即是队首结点又是队尾结点*/if(Q->rear == NULL){Q->front = Q->rear = newP;}else{/* 若链队非空，则依次修改队尾结点的指针域和队尾指针，使之指向新的队尾结点*/ Q->rear = Q->rear->next = newP;/*可以分两句话来写*/}}elemType pop(struct LinkQueue *Q)/*第三个操作队列不为空，则删除q的队头元素，用e返回其值，并返回ok；*/{struct QueuePtr *p;elemType temp;/* 若链队为空则停止运行*/if(Q->front == NULL){printf("队列为空，无法删除！");exit(1);}temp = Q->front->data;/* 暂存队尾元素以便返回*/p = Q->front;/* 暂存队尾指针以便回收队尾结点*/Q->front = p->next;/* 使队首指针指向下一个结点*//* 若删除后链队为空，则需同时使队尾指针为空*/if(Q->front == NULL){Q->rear = NULL;}free(p);/* 回收原队首结点*/return temp; /* 返回被删除的队首元素值*/}/*第四个操作返回队列头元素*/elemType gettop(struct LinkQueue *Q){/* 若链队为空则停止运行*/if(Q->front == NULL){printf("队列为空，无法删除！");exit(1);}return Q->front->data;/* 返回队首元素*/}/*第五个操作判断队列是否为空*/int emptyQueue(struct LinkQueue *Q){/* 判断队首或队尾任一个指针是否为空即可*/if(Q->front == NULL){printf("asd");return 0;}else{printf("dfg");return 1;}}/*第六个操作清空队列*/void clearQueue(struct LinkQueue *Q){struct QueuePtr *p = Q->front;/* 队首指针赋给p *//* 依次删除队列中的每一个结点，最后使队首指针为空*/ while(p != NULL){Q->front = Q->front->next;free(p);p = Q->front;}/* 循环结束后队首指针已经为空*/Q->rear = NULL;printf("\n队列已经清空\n");return;}int main(){struct LinkQueue Q;int i;int a,b,c,d;a=b=c=d=0;// initQueue(&q);while(1){printf("\n每种方法都对应一个编号，输入编号进行相应的操作。

队列的基本操作操作命令选择型的测试程序

工作（学习）日志日期时间：2012年11月5日20:37:54主题：队列的基本操作操作命令选择型的测试程序内容：#include<stdio.h>#include<stdlib.h>#include"lc.h"#define ElemType int#define MAXSIZE 50typedef struct squeue//用数组表示一定容量的队列，队首与队尾确定之后（中间的任何一个元素是联系着的，能够访问到），则一定容量的队列也就确定了{ElemType data[MAXSIZE];int rear; //指向队尾元素的下一个位置int front; //指向队手元素}SqQueue;//链式队列存储类型的定义（有时候复杂的数据类型可能会出现结构套结构，或者其他数据类型的情况）//队列的本质，即由多个结点链接而成，每个节点是一个结点结构体，由首尾指针指示队首与队尾的位置。

队首与队尾的指针确定之后（中间的不用管，因为他们有指针相连由结点的指针域确定）一定容量的队列也就确定了typedef struct lqueue_node{ElemType data;struct lqueue_node *next;//这样只含这样两种数据类型的结构体，只是形成的链表结点，只是这样的对链表结点的指针域赋值即在逻辑上形成了一条链表，并没有其他类型的数据结构。

只是为其他类型的数据结构提高了一种链式存储结构，比如前面的栈，一条链表所含的数据元素的操作足以满足栈的所有操作}LinkNode;typedef struct lqueue//要是一条链表所含的数据元素的操作无法达到要求，比如说队列的队首，队尾指针无法再链表中体现？？？？？？？？？？？？不明白了到这里{LinkNode *rear,*front;//由两个指针域组成}LinkQueue;/*******************第一部分：（循环）顺序队列的基本操作*************//*********************队列的初始化***********************/SqQueue *Init_SqQueue(){SqQueue *S;S=(SqQueue *)malloc(sizeof(SqQueue));S->front =0;S->rear=0;return S;}/*********************done****************************//*********************（循环）队列的判空***********************/Status Empty_SqQueue(SqQueue *S){if(S->rear==S->front)//这里的fear=front,为空的唯一条件，区别于队满{printf("\n队列空\n");return TRUE;}else{printf("队列不空");return FALSE;}}/*********************done****************************//*********************元素的入队列***********************/Status En_SqQueue(SqQueue *S,ElemType x){//入队列首先盘队列是否满了if((S->rear+1)%MAXSIZE==S->front) return ERROR;//牺牲一个内存单元来使队满的条件为(rear+1)%MAXSIZE和front相同,这样就可以和对空的条件rear=front S->data[S->rear]=x;//有了这一个队尾指针进1的方法，rear的值只能在0----MAXSIZE-1之间了，不会出现>=maxsize的情况，所以当rear值达到maxsize-1时，加一自动会跳到0的位置S->rear=(S->rear+1)%MAXSIZE; //有了这一个队尾指针进1的方法，fear的值只能在0----MAXSIZE-1之间了，不会出现>=maxsize的情况return OK;}/*********************done****************************//*********************元素的出队列***********************/Status De_SqQueue(SqQueue *S){if(S->rear ==S->front) return ERROR;S->front=(S->front+1)%MAXSIZE;return OK;}/*********************done****************************//*********************打印队列元素********************/void Print_SqQueue(SqQueue *S){int n;printf("\n当前队列：<队首");for(n=S->front;n<S->rear;n++)printf(" %d",S->data[n]);printf(" 队尾>");}/*********************done****************************//*********第二部分：（循环）链式队列的基本操作*****************//*********************队列的初始化**************************/ LinkQueue *Init_LinkQueue(){LinkQueue *L;L=(LinkQueue*)malloc(sizeof(LinkQueue));//新队列L->front=L->rear=(LinkNode*)malloc(sizeof(LinkNode));//头节点L->front->next=NULL;return L;}/***********************done***************************//***********************入队列***************************/ Status En_LinkQueue(LinkQueue *L,ElemType x){LinkNode *newnode;newnode=(LinkNode*)malloc(sizeof(LinkNode));newnode->data=x;newnode->next=NULL;L->rear->next=newnode;//构链链表L->rear=newnode;//指明队尾位置return OK;}/***********************done***************************//***********************队首删除元素***************************/Status De_LinkQueue(LinkQueue *L){LinkNode *p;p=L->front->next;L->front->next=p->next;//构链free(p);return OK;}/***********************done***************************//***********************队列判空***************************/ Status Empty_LinkQueue(LinkQueue *L){if(L->front==L->rear){printf("\n队列空\n");return TRUE;}else{printf("\n队列不空\n");return FALSE;}}/***********************打印队列***************************/ void Print_LinkQueue(LinkQueue *L){LinkNode *p;p=L->front->next;printf("\n当前队列内容：<队首");while(p){printf(" %d",p->data);p=p->next;}printf(" 队尾>");}/***********************done***************************//*************显示菜单********************************/ void Show_menu(){printf("\n ※顺序队列操作| ※链队列操作\n");printf(" 1)队列初始化| 5)队列初始化\n");printf(" 2)队列判空| 6)队列判空\n");printf(" 3)入队列| 7)入队列\n");printf(" 4)出队列| 8)出队列\n");printf(" 9)退出程序\n");printf("请输入要进行的操作:");}/*********************done****************************/void main(){/*该部分为测试单个程序所用SqQueue *s;ElemType r1,r2,r3;//初始化s=Init_SqQueue();//判空？Empty_SqQueue(s);//入队列printf("\n请输入你要入队列的值：");scanf("%d",&r1);En_SqQueue(s,r1);Print_SqQueue(s);printf("\n请输入你要入队列的值：");scanf("%d",&r2);En_SqQueue(s,r2);Print_SqQueue(s);printf("\n请输入你要入队列的值：");scanf("%d",&r3);En_SqQueue(s,r3);Print_SqQueue(s);//出队列printf("\n\n出队列操作\n");Print_SqQueue(s);Empty_SqQueue(s);printf("\n第一次出队列结果\n"); De_SqQueue(s);Print_SqQueue(s);Empty_SqQueue(s);printf("\n第二次出队列结果\n"); De_SqQueue(s);Print_SqQueue(s);Empty_SqQueue(s);printf("\n第三次出队列结果\n"); De_SqQueue(s);Print_SqQueue(s);Empty_SqQueue(s);LinkQueue *q;q=Init_LinkQueue();En_LinkQueue(q,1);Print_LinkQueue(q);De_LinkQueue(q);Print_LinkQueue(q);*///正式程序：LinkQueue *q;ElemType R;SqQueue *s;ElemType r;int choice;int en1=0,en2=0;//de初始化标志符号while(1){Show_menu();scanf("%d",&choice);if(choice==9) break;switch(choice){case 1:s=Init_SqQueue();printf("\n初始化完毕\n");Print_SqQueue(s);break;//switch case 语句中case 后面有多个语句时可以不用{}括起来case 2:s=Init_SqQueue();Empty_SqQueue(s);break;//switch case 语句中case 后面有多个语句时可以不用{}括起来case 3:if(!en1) s=Init_SqQueue();//只在第一次进行入队列操作的时候执行初始化程序*******很重要的一个方法，标志法，开始设置一个初值，然后在程序中改变该值，然后检查其的变化while(1){printf("\n请输入要入栈的值：(输入0结束)");scanf("%d",&r);if(r){En_SqQueue(s,r);en1++;//供下面检测是否已经进行入队列操作Print_SqQueue(s);}elsebreak;}break;//switch case 语句中case 后面有多个语句时可以不用{}括起来case 4:if(!en1){s=Init_SqQueue();Print_SqQueue(s);En_SqQueue(s,100);En_SqQueue(s,200);En_SqQueue(s,300);En_SqQueue(s,400);En_SqQueue(s,500);En_SqQueue(s,600);Print_SqQueue(s);}De_SqQueue(s);Empty_SqQueue(s);Print_SqQueue(s);en1++;break;//switch case 语句中case 后面有多个语句时可以不用{}括起来case 5:q=Init_LinkQueue();printf("\n初始化完毕\n");Print_LinkQueue(q);break;//switch case 语句中case 后面有多个语句时可以不用{}括起来case 6:q=Init_LinkQueue();Empty_LinkQueue(q);break;//switch case 语句中case 后面有多个语句时可以不用{}括起来case 7:if(!en2) q=Init_LinkQueue();while(1){printf("\n请输入要入队列的值：(输入0结束)");scanf("%d",&R);if(R){En_LinkQueue(q,R);Print_LinkQueue(q);en2++;}elsebreak;}break;//switch case 语句中case 后面有多个语句时可以不用{}括起来case 8:if(!en2){q=Init_LinkQueue();Print_LinkQueue(q);En_LinkQueue(q,100);En_LinkQueue(q,200);En_LinkQueue(q,300);En_LinkQueue(q,400);En_LinkQueue(q,500);En_LinkQueue(q,600);En_LinkQueue(q,700);Print_LinkQueue(q);}De_LinkQueue(q);Empty_LinkQueue(q);Print_LinkQueue(q);en2++;break;//switch case 语句中case 后面有多个语句时可以不用{}括起来}}printf("\n程序已退出\n");}心得：。

《数据结构》课程实验实训报告--堆栈和队列的基本操作。

}
if(StackTop(myStack,&x)==0)
{
printf("error!\n");
return;
}
else
printf("The element of local top is :%d\n",x);
printf("The sequence of outing elements is:\n");
(*head)->next = NULL;
}/*判非空操作：*/
int StackNotEmpty(LSNode *head) /*判堆栈是否非空，非空返回1；空返回0*/
{
if(head->next == NULL) return 0; else return 1;
}/*入栈操作：*/
int StackPush(LSNode *head, DataType x) /*把数据元素x插入链式堆栈head的栈顶作为新的栈顶*/ { LSNode *p; if((p = (LSNode *)malloc(sizeof(LSNode))) == NULL) { printf("内存空间不足无法插入! \n"); return 0; } p->data = x; p->next = head->next; /*新结点链入栈顶*/ head->next = p; /*新结点成为新的栈顶*/ return 1; } /*出栈操作：*/
依次把5个元素入栈然后出栈并在屏幕上显示出栈的数据元对顺序循环队列常规的方法是使用队尾指针和队头指针队尾指针用于指示当前的队尾位置下标队头指针用于指示当前的队头位置下标
《数据结构》课程实验实训报告

实验四队列的基本操作与应用实验报告

入队：Status EnQueue (LinkQueue &Q, QElemType e){ // 插入元素e为Q的新队尾元素p = (QueuePtr) malloc (sizeof (QNode)); //生成新结点if (!p) exit (OVERFLOW); //存储分配失败p->data = e; p->next = NULL; //插入队尾Q.rear->next = p;Q.rear = p; //修改队尾指针指向队尾return OK;}出队：Status DeQueue (LinkQueue &Q, QElemType &e){ // 若队列不空，则删除Q的队头元素，用e 返回其值if (Q.front == Q.rear) return ERROR; //判空p = Q.front->next; e = p->data; //用e返回队头元素值Q.front->next = p->next; //修改头指针始终指向队首元素if (Q.rear == p) Q.rear = Q.front; //特殊情况处理空队free (p); //释放队首结点return OK;}代码一：#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q);void DestroyQueue(LiQueue *&q);bool QueueEmpty(LiQueue *q);void enQueue(LiQueue *&q, ElemType e);bool deQueue(LiQueue *&q, ElemType &e);void InitQueue(LiQueue *&q)//初始化队列{q = (LiQueue *)malloc(sizeof(LiQueue));q->front = q->rear = NULL;}void DestroyQueue(LiQueue *&q)//销毁队列{QNode *p = q->front, *r;//p指向队头数据节点if (p != NULL)//释放数据节点占用空间{r = p->next;while (r != NULL){free(p);p = r; r = p->next;}}free(p);free(q);//释放链队节点占用空间}bool QueueEmpty(LiQueue *q)//判断队列是否为空{return(q->rear == NULL);}void enQueue(LiQueue *&q, ElemType e)//进队{QNode *p;p = (QNode *)malloc(sizeof(QNode));p->data = e;p->next = NULL;if (q->rear == NULL)//若链队为空,则新节点是队首节点又是队尾节点q->front = q->rear = p;else{q->rear->next = p;//将*p节点链到队尾,并将rear指向它q->rear = p;}}bool deQueue(LiQueue *&q, ElemType &e)//出队{QNode *t;if (q->rear == NULL)//队列为空return false;t = q->front;//t指向第一个数据节点if (q->front == q->rear) //队列中只有一个节点时q->front = q->rear = NULL;else//队列中有多个节点时q->front = q->front->next;e = t->data;free(t);return true;}void main(){ElemType e;LiQueue *q;printf("链队的基本运算如下:\n");printf(" (1)初始化链队q\n");InitQueue(q);printf(" (2)依次进链队元素a,b,c\n");enQueue(q, 'a');enQueue(q, 'b');enQueue(q, 'c');printf(" (3)链队为%s\n", (QueueEmpty(q) ? "空" : "非空"));if (deQueue(q, e) == 0)printf("\t提示:队空,不能出队\n");elseprintf(" (4)出队一个元素%c\n", e);printf(" (5)依次进链队元素d,e,f\n");enQueue(q, 'd');enQueue(q, 'e');enQueue(q, 'f');printf(" (6)出链队序列:");while (!QueueEmpty(q)){deQueue(q, e);printf("%c ", e);}printf("\n");printf(" (7)释放链队\n");DestroyQueue(q);}代码二：#include <stdio.h>#include <malloc.h>typedef struct qnode{int data;struct qnode *next;} QNode;//链队节点类型typedef struct{QNode *front, *rear;} QuType;//链队类型void Destroyqueue(QuType *&qu)//释放链队{QNode *p, *q;p = qu->front;if (p != NULL)//若链队不空{q = p->next;while (q != NULL)//释放队中所有的节点{free(p);p = q;q = q->next;}free(p);}free(qu);//释放链队节点}void SeeDoctor(){int sel, flag = 1, find, no;QuType *qu;QNode *p;qu = (QuType *)malloc(sizeof(QuType));//创建空队qu->front = qu->rear = NULL;while (flag == 1) //循环执行{printf("1:排队2:就诊3:查看排队4.不再排队,余下依次就诊5:下班请选择:");scanf("%d", &sel);switch (sel){case 1:printf(" >>输入病历号:");do{scanf("%d", &no);find = 0;p = qu->front;while (p != NULL && !find){if (p->data == no)find = 1;elsep = p->next;}if (find)printf(" >>输入的病历号重复,重新输入:");} while (find == 1);p = (QNode *)malloc(sizeof(QNode));//创建节点p->data = no; p->next = NULL;if (qu->rear == NULL)//第一个病人排队qu->front = qu->rear = p;else{qu->rear->next = p; qu->rear = p;//将*p节点入队}break;case 2:if (qu->front == NULL)//队空printf(" >>没有排队的病人!\n");else//队不空{p = qu->front;printf(" >>病人%d就诊\n", p->data);if (qu->rear == p)//只有一个病人排队的情况qu->front = qu->rear = NULL;elsequ->front = p->next;free(p);}break;case 3:if (qu->front == NULL) //队空printf(" >>没有排列的病人!\n");else //队不空{p = qu->front;printf(" >>排队病人:");while (p != NULL){printf("%d ", p->data);p = p->next;}printf("\n");}一:二：总结体会：通过本次实验掌握了链式存储队列的进队和出队等基本操作，通过这些基本操作，我对队列问题有了更深的理解，能够正确理解队列问题及其使用。

链队列实验报告

一、实验目的1. 理解链队列的基本概念和特点。

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

3. 学会使用链队列解决实际问题。

二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio 2019三、实验内容1. 链队列的创建- 创建一个带头结点的链队列。

- 使用循环链表实现链队列。

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

- 在链队列头部插入一个元素。

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

- 从链队列尾部删除一个元素。

4. 链队列的遍历操作- 遍历链队列中的所有元素，并输出。

5. 链队列的销毁操作- 销毁链队列，释放内存空间。

四、实验过程1. 链队列的创建- 定义一个链队列的节点结构体，包含数据域和指针域。

- 创建一个带头结点的链队列，初始化头结点指针为NULL。

2. 链队列的插入操作- 在链队列尾部插入一个元素：- 创建一个新的节点，初始化数据域和指针域。

- 将新节点插入到链队列尾部。

- 在链队列头部插入一个元素：- 创建一个新的节点，初始化数据域和指针域。

- 将新节点插入到链队列头部，并更新头结点指针。

3. 链队列的删除操作- 从链队列头部删除一个元素：- 获取头结点指针指向的节点。

- 更新头结点指针，指向下一个节点。

- 释放被删除节点的内存空间。

- 从链队列尾部删除一个元素：- 获取头结点指针指向的节点。

- 遍历链队列，找到倒数第二个节点。

- 将倒数第二个节点的指针域指向NULL，释放被删除节点的内存空间。

4. 链队列的遍历操作- 遍历链队列中的所有元素，并输出：- 获取头结点指针指向的节点。

- 遍历链队列，输出每个节点的数据域。

5. 链队列的销毁操作- 销毁链队列，释放内存空间：- 获取头结点指针指向的节点。

- 遍历链队列，释放每个节点的内存空间。

五、实验结果与分析1. 链队列的创建成功，实现了带头结点的循环链表。

队列的实现及应用实验原理

队列的实现及应用实验原理1. 队列的定义和基本操作队列是一种先进先出（FIFO）的数据结构，它的插入操作在队列的一端进行，而删除操作则在队列的另一端进行。

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

•初始化：创建一个空队列。

•入队：将元素插入到队列的末尾。

•出队：删除队列的头部元素，并返回该元素。

•判空：检查队列是否为空。

2. 队列的实现方式队列可以通过数组或链表来实现。

每种实现方式都有其优缺点。

2.1 数组实现队列使用数组实现队列时，需要定义队头和队尾指针，分别指向队列的头部和尾部。

队头指针指向队列中的第一个元素，队尾指针指向队列中的最后一个元素。

2.1.1 初始化使用数组实现队列时，需要初始化队头指针和队尾指针。

队头指针和队尾指针初始值都为-1，表示队列为空。

2.1.2 入队入队操作即向队列中插入元素。

当插入一个新元素时，队尾指针先加1，然后将元素存储在队尾指针所指向的位置。

2.1.3 出队出队操作即删除队列中的一个元素。

当删除一个元素时，队头指针先加1，然后返回队头指针所指向的元素。

2.1.4 判空判空操作用于检查队列是否为空。

当队头指针等于队尾指针时，表示队列为空。

2.2 链表实现队列链表实现队列时，可以使用单链表或双向链表。

在链表实现中，只需保存队列的头部和尾部节点即可。

2.2.1 初始化使用链表实现队列时，需要初始化头部和尾部节点，将它们都指向空节点。

2.2.2 入队入队操作即向队列中插入元素。

当插入一个新元素时，将其作为新的尾部节点，并更新尾部节点指针。

2.2.3 出队出队操作即删除队列中的一个元素。

当删除一个元素时，将头部节点指向下一个节点，并返回被删除的节点。

2.2.4 判空判空操作用于检查队列是否为空。

当头部节点和尾部节点都指向空节点时，表示队列为空。

3. 队列的应用实验原理队列的应用非常广泛，在很多算法和实验中都有着重要的作用。

以下是一些常见的队列应用实验原理：3.1 广度优先搜索（BFS）广度优先搜索是一种图遍历算法，它使用队列来实现。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

{
if(!Empty())
{
Node<ElemType>* tmpPtr = front->next;
e = tmpPtr->data;
return SUCCESS;
}
else
return UNDER_FLOW;
}
template <class ElemType>
StatusCode QueueLink<ElemType>::EnQueue(const ElemType &e)
{
return rear == front;
}
template <class ElemType>
void QueueLink<ElemType>::Clear()
{
ElemType tmpElem;
while(Lengh() > 0)
{
OutQueue(tmpElem);
}
}
template <class ElemType>
{
Init();
for(Node<ElemType> *tmpPtr = copy.front ->next;tmpPtr != NULL;tmpPtr = tmpPtr->next;)
InQueue(tmpPtr->data);
}
template <class ElemType>
QueueLink<ElemType>& QueueLink<ElemType>::operator=(const QueueLink<ElemType> &copy)
#include <iostream>
using namespace std;
template <class ElemType>
class QueueLink
{
protected:
Node<ElemType> *front,*rear;
void Init();
public:
LinkQueue(); //无参数的构造函数
}
}
template <class ElemType>
StatusCode QueueLink<ElemType>::OutQueue(ElemType &e)
{
if(!Empty())
{
Node<ElemType> *tmpPtr = front->next;
e = tmpPtr->data;
front ->next = tmpPtr ->next;
StatusCode GetHead(ElemType &e) const; //取队头操作
StatusCode EnQueue(const ElemType &e); //入队操作
LinkQueue(const LinkQueue<ElemType> &copy); //复制构造函数
LinkQueue<ElemType>&operator = (const LinkQueue<ElemType> &copy); //赋值运算符重载
}
template <class ElemType>
void QueueLink<ElemType>::Init()
{
rear = front = new Node<ElemType>;
}
template <class ElemType>
QueueLink<ElemType>::LinkQueue()
void QueueLink<ElemType>::Traverse(void(*Visit)(ElemType &))
{
for(Node<ElemType> *tmpPtr = front->next;tmpPtr != NULL;tmpPtr = tmpPtr->next)
{
(*Visit)(tmpPtr->data);
{
Init();
}
template <class ElemType>
QueueLink<ElemType>::~LinkQueue()
{
Clear();
}
template <class ElemType>
int QueueLink<ElemType>::Length()const
{
int count = 0;
{
if(&copy != this)
{
Clear();
for(Node<ElemType> *tmpPtr = copy.front ->next;tmpPtr != NULL;tmpPtr = tmpPtr->next;)
{
InQueue(tmpPtr->data);
}
}
return *this;
{
Node<ElemType> *tmpPtr = new Node<ElemType>(e);
rear->next = tmpPtr;
rear = tmpPtr;
return SUCCESS;
}
template <class ElemType>
QueueLink<ElemType>& QueueLink<ElemType>::LinkQueue(const QueueLink<ElemType> &copy)
virtual ~LinkQueue();
int Length() const; //求队列长度
bool QueueEmpty() const;
void Clear();
void Traverse(void(*Visit)(ElemType &)); //遍历队列
StatusCode OutQueue(ElemType &e); //出队操作
}
for(Node<ElemType> *tmpPtr = front->next;tmpPtr != NULL;tmpPtr = tmpPtr->next)
count++;
return count;
}
template <class ElemType>
bool QueueLink<ElemType>::QueueEmpty() const
if(rear == tmpPtr)
rear == front;
delete tmpPtr;
return SUCCESS;
}
else
return UNDER_Fss ElemType>
StatusCode QueueLink<ElemType>::GetHead(ElemType &e) const