c++,链队列的基本操作(创建,销毁,查找,删除,插入等)

合集下载

单链表课程设计

单链表课程设计

单链表课程设计一、课程目标知识目标:1. 学生能理解单链表的基本概念,掌握其结构特点及在数据结构中的重要性。

2. 学生能够运用所学知识,实现单链表的创建、插入、删除和查找等基本操作。

3. 学生能够掌握单链表与数组、栈、队列等其他数据结构的关系与区别。

技能目标:1. 学生能够运用编程语言(如C、C++等)实现单链表的相关操作,提高编程能力。

2. 学生能够通过实际操作,培养解决实际问题的能力,提高逻辑思维能力。

情感态度价值观目标:1. 学生通过学习单链表,培养对数据结构的兴趣,提高学习积极性。

2. 学生在学习过程中,学会与他人合作,培养团队精神和沟通能力。

3. 学生能够认识到数据结构在计算机科学中的重要性,增强对专业知识的认同感。

课程性质分析:本课程为计算机科学与技术专业的基础课程,旨在让学生掌握单链表这一基础数据结构,为后续学习更复杂的数据结构打下基础。

学生特点分析:学生已具备基本的编程能力,具有一定的逻辑思维能力,但可能对数据结构的应用场景认识不足,需要通过实际案例激发兴趣。

教学要求:1. 结合实际案例,讲解单链表的理论知识,让学生了解其在实际问题中的应用。

2. 通过课堂讲解、上机实践等教学手段,让学生掌握单链表的相关操作。

3. 注重培养学生的编程能力和逻辑思维能力,提高解决实际问题的能力。

二、教学内容1. 单链表基本概念:介绍单链表的定义、结构特点及其在数据结构中的应用场景。

- 教材章节:第二章第二节- 内容安排:讲解单链表的组成元素(节点、指针)、分类(单向、双向)及优缺点。

2. 单链表基本操作:- 教材章节:第二章第三节- 内容安排:讲解单链表的创建、插入、删除、查找等基本操作,并通过实例演示。

3. 单链表与其它数据结构的对比:- 教材章节:第二章第四节- 内容安排:分析单链表与数组、栈、队列等其他数据结构的区别和联系,突出单链表的特点。

4. 单链表编程实践:- 教材章节:第二章第五节- 内容安排:结合上机实践,让学生动手实现单链表的基本操作,培养编程能力和解决实际问题的能力。

c语言中list的用法

c语言中list的用法

C语言中list的用法1.简介在C语言中,l is t是一种常用的数据结构,用于存储和管理多个元素。

它类似于数组,但具有更强大的灵活性和功能。

本文将介绍C语言中l i st的使用方法,包括创建、添加、删除和遍历等操作。

2.创建lis t要使用l is t,首先需要定义一个结构体来表示l is t的节点,节点中包含数据元素和指向下一个节点的指针。

然后,使用指向该结构体的指针来表示整个l is t。

以下是创建l is t的基本代码:t y pe de fs tr uc tN ode{i n td at a;s t ru ct No de*n ex t;}N od e;t y pe de fs tr uc t{N o de*h ea d;}L is t;3.添加元素要向li st中添加元素,可以使用以下代码:v o id ad dE le me nt(Li s t*li st,i nt ne wDa t a){N o de*n ew No de=(Nod e*)ma ll oc(s iz eof(No de));n e wN od e->d at a=new D at a;n e wN od e->n ex t=NUL L;i f(l is t->h ea d==NU L L){l i st->he ad=n ew Nod e;}e ls e{N o de*c ur re nt No de=l is t->h ea d;w h il e(cu rr en tN ode->n ex t!=N UL L){c u rr en tN od e=cu rre n tN od e->n ex t;}c u rr en tN od e->n ext=ne wN od e;}}4.删除元素要从li st中删除元素,可以使用以下代码:v o id re mo ve El em ent(Li st*l is t,in tta r ge t){ N o de*c ur re nt No de=l is t->h ea d;N o de*p re vN od e=NUL L;w h il e(cu rr en tN ode!=N UL L){i f(c ur re nt No de->d a ta==ta rg et){i f(p re vN od e==N ULL){l i st->he ad=c ur ren t No de->ne xt;}e ls e{p r ev No de->ne xt=cu r re nt No de->ne xt;}f r ee(c ur re nt No de);b r ea k;}p r ev No de=c ur re ntN o de;c u rr en tN od e=cu rre n tN od e->n ex t;}}5.遍历lis t要遍历l is t中的所有元素,可以使用以下代码:v o id tr av er se Li st(L is t*li st){N o de*c ur re nt No de=l is t->h ea d;w h il e(cu rr en tN ode!=N UL L){p r in tf("%d",cu rre n tN od e->d at a);c u rr en tN od e=cu rre n tN od e->n ex t;}}6.示例下面是一个使用l ist的示例:#i nc lu de<s td io.h>#i nc lu de<s td li b.h>t y pe de fs tr uc tN ode{i n td at a;s t ru ct No de*n ex t;}N od e;t y pe de fs tr uc t{N o de*h ea d;}L is t;v o id ad dE le me nt(Li s t*li st,i nt ne wDa t a){N o de*n ew No de=(Nod e*)ma ll oc(s iz eof(No de)); n e wN od e->d at a=new D at a;n e wN od e->n ex t=NUL L;i f(l is t->h ea d==NU L L){l i st->he ad=n ew Nod e;}e ls e{N o de*c ur re nt No de=l is t->h ea d;w h il e(cu rr en tN ode->n ex t!=N UL L){c u rr en tN od e=cu rre n tN od e->n ex t;}c u rr en tN od e->n ext=ne wN od e;}}v o id re mo ve El em ent(Li st*l is t,in tta r ge t){N o de*c ur re nt No de=l is t->h ea d;N o de*p re vN od e=NUL L;w h il e(cu rr en tN ode!=N UL L){i f(c ur re nt No de->d a ta==ta rg et){i f(p re vN od e==N ULL){l i st->he ad=c ur ren t No de->ne xt;}e ls e{p r ev No de->ne xt=cu r re nt No de->ne xt; }f r ee(c ur re nt No de);b r ea k;}p r ev No de=c ur re ntN o de;c u rr en tN od e=cu rre n tN od e->n ex t;}}v o id tr av er se Li st(L is t*li st){N o de*c ur re nt No de=l is t->h ea d;w h il e(cu rr en tN ode!=N UL L){p r in tf("%d",cu rre n tN od e->d at a);c u rr en tN od e=cu rre n tN od e->n ex t;}}i n tm ai n(){L i st my Li st;m y Li st.h ea d=NU LL;a d dE le me nt(&my Lis t,5);a d dE le me nt(&my Lis t,10);a d dE le me nt(&my Lis t,15);r e mo ve El em en t(&my L is t,10);t r av er se Li st(&myL i st);r e tu rn0;}7.总结使用li st可以轻松地管理多个元素,实现灵活的数据存储和操作。

c语言链表的基本操作

c语言链表的基本操作

c语言链表的基本操作(1)单链表的创建// 定义单链表结构体struct Node{int data; // 节点元素值struct Node *next; // 指向下一节点的指针};// 创建单链表struct Node * list_create(){struct Node *head; // 保存头节点struct Node *p1, *p2; // 临时指针int data;// 分配新节点p1 = (struct Node *)malloc(sizeof(struct Node));p2 = p1; // 维持p1指向新节点printf("Please input data:\n");scanf("%d", &data);// 保存数据和指针p1->data = data;p1->next = NULL;if(data != 0) {// 循环录入while(data != 0) {// 分配新节点p1 = (struct Node *)malloc(sizeof(struct Node));p1->next = NULL;// 保存数据scanf("%d", &data);p1->data = data;p2->next = p1;p2 = p1;}}head = p1;printf("Single list create success!!\n");return head;}(2)单链表的插入// 向单链表插入元素void list_insert(struct Node *list){struct Node *p1, *p2;int data;printf("Please input insert data:\n");scanf("%d", &data);// 分配新节点p1 = (struct Node *)malloc(sizeof(struct Node));p1->data = data; // 保存数据p2 = list; // p2指向头指针// 查找插入位置while ((p2 != NULL) && (p2->data < data)){p1 = p2;p2 = p2->next; // 遍历单链表}if (list == p2) // 在最前面插入{p1 = p2; // p1头指针指向头结点list = p1;}// 保存插入位置p1->next = p2;// 插入新节点p1->next->next = p2->next;printf("List insert success!!\n");}(3)单链表的删除// 删除单链表中的节点void list_delete (struct Node *list){struct Node *p1, *p2;int data;printf("Please input delete data:\n");scanf("%d", &data);p1 = list;// 查找删除位置while ((p1->next != NULL) && (p1->next->data < data)) {p1 = p1->next; // 遍历单链表}// 找到要删除的节点if (p1->next->data == data){p2 = p1->next; // 保存要删除的节点p1->next = p2->next; // 指针指向要删除的下一节点// 释放要删除的节点free(p2);printf("List delete success!!\n");}else{printf("No data in list!!\n");}}(4)单链表的查找// 查找单链表中的元素void list_fetch (struct Node *list){struct Node *p;int data;p = list;printf("Please input fetch data:\n");scanf("%d", &data);// 查找插入位置while (p != NULL){if (p->data == data){printf("Fetch success!!\n");break;}p = p->next; // 指针指向下一节点}if (p == NULL){printf("No data in list!!\n");}}(5)单链表的遍历// 遍历单链表void list_traverse (struct Node *list){struct Node *p;printf("Single list traverse: \n");p = list;while (p != NULL) // 遍历单链表{printf("%d ", p->data);p = p->next;}}(6)单链表的销毁// 销毁单链表void list_destory (struct Node *list){struct Node *p;while (list != NULL){p = list; // 保存头指针list = list->next; // 移除头节点// 释放free (p);}printf("Destory list!!\n");}。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构与算法考试

数据结构与算法考试

数据结构与算法考试(答案见尾页)一、选择题1. 什么是数据结构?请列举几种常见的数据结构。

A. 数组B. 链表C. 栈D. 队列E. 图2. 算法的时间复杂度是如何表示的?请简述其计算方式。

A. 用大O符号表示B. 用大O符号表示C. 用大O符号表示D. 用大O符号表示3. 什么是递归?请举例说明递归在算法中的实现。

A. 一个函数调用自身B. 一个函数调用自身的过程C. 一个函数调用自身的过程D. 一个函数调用自身的过程4. 什么是排序算法?请列举几种常见的排序算法,并简要描述它们的特点。

A. 冒泡排序B. 选择排序C. 插入排序D. 快速排序E. 归并排序5. 什么是哈希表?请简述哈希表的原理和优点。

A. 一种数据结构,它通过将键映射到数组索引来存储和检索数据B. 一种数据结构,它通过将键映射到数组索引来存储和检索数据C. 一种数据结构,它通过将键映射到数组索引来存储和检索数据D. 一种数据结构,它通过将键映射到数组索引来存储和检索数据6. 什么是树形结构?请列举几种常见的树形结构,并简要描述它们的特点。

A. 二叉树B. 二叉树C. B树D. B+树E. 无7. 什么是图数据结构?请列举几种常见的图算法,并简要描述它们的特点。

A. 广度优先搜索B. 深度优先搜索C. 最短路径算法(Dijkstra算法)D. 最长路径算法(Floyd算法)E. 最小生成树算法(Kruskal算法,Prim算法)8. 什么是动态规划?请简述动态规划的基本思想和应用场景。

A. 一种通过分解问题为更小的子问题来求解的方法B. 一种通过分解问题为更小的子问题来求解的方法C. 一种通过分解问题为更小的子问题来求解的方法D. 一种通过分解问题为更小的子问题来求解的方法9. 请简述贪心算法的基本思想以及在哪些问题上可以应用贪心算法。

A. 一种通过局部最优解来达到全局最优解的策略B. 一种通过局部最优解来达到全局最优解的策略C. 一种通过局部最优解来达到全局最优解的策略D. 一种通过局部最优解来达到全局最优解的策略10. 什么是算法的时间复杂度和空间复杂度?请简述它们的含义以及如何计算它们。

数据结构链表的基本操作

数据结构链表的基本操作

数据结构链表的基本操作一、引言链表是计算机科学中的一种数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表可以用于实现栈、队列和其他数据结构。

本文将详细介绍链表的基本操作。

二、链表的基本概念1. 节点:链表中的每个元素称为节点,它包含两部分:数据和指向下一个节点的指针。

2. 头结点:链表中第一个节点称为头结点,它不包含实际数据,只有指向第一个真正节点的指针。

3. 尾节点:链表中最后一个节点称为尾节点,它的指针为空。

4. 空链表:不包含任何元素的链表称为空链表。

三、链表的基本操作1. 创建链表创建一个空链表很简单,只需要让头结点指针为空即可。

如果需要创建带有多个元素的非空链表,则需要依次创建每个节点,并将前一个节点的指针指向当前节点。

2. 插入元素在插入元素时,需要先找到要插入位置前面的那个节点。

然后新建一个要插入的节点,并将其指针指向原来位置上后面那个节点。

最后将前面那个节点的指针改为新建立的节点。

3. 删除元素在删除元素时,需要先找到要删除的那个节点。

然后将前一个节点的指针指向后一个节点,从而跳过要删除的那个节点。

最后释放要删除的节点。

4. 遍历链表遍历链表是指依次访问链表中每个元素。

可以使用循环结构来实现遍历操作。

从头结点开始,依次访问每个节点,并将其数据输出即可。

5. 查找元素查找元素时,需要从头结点开始依次遍历每个节点,直到找到目标元素或者遍历完整个链表为止。

6. 反转链表反转链表是指将原来的链表顺序倒置。

可以使用三个指针分别表示当前节点、前一个节点和后一个节点,依次修改它们之间的指针即可实现反转操作。

四、链表的应用举例1. 栈和队列:栈和队列都可以用链表来实现。

栈是一种先进后出(FILO)的数据结构,而队列是一种先进先出(FIFO)的数据结构。

2. 链式存储文件系统:文件系统中通常采用基于树或者基于哈希表的存储方式。

但是在某些情况下,也可以采用基于链式存储方式来实现文件系统。

队列的常见操作

队列的常见操作

数据结构面试之四——队列的常见操作题注:《面试宝典》有相关习题,但思路相对不清晰,排版有错误,作者对此参考相关书籍和自己观点进行了重写,供大家参考。

四、队列的基本操作1.用数组构造队列队列即是满足先进先出的链表。

用数组存储的话,同样需要满足队列头front出栈,队列末尾rear入栈。

而对于数组来讲,rear和front可以代表数组头和尾。

不能简单的固定rear 和front的大小为maxSize和0,因为可能出现中间元素为空的现象。

所以,对于数组队列来讲,可以想象成环式存储,因为每一次入队后rear+1,每一次出队后front+1。

这就需要控制front和rear的大小,每一次修改只要满足front=(front+1)%maxSize,rear=(rear+1)%maxSize即可满足要求。

同样需要注意:入队操作前先判定队列是否已经满;出队操作前先判定队列是否为空。

template<typename Type>class arrQueue{public:arrQueue(intnSize=100);~arrQueue();arrQueue(constarrQueue<Type>& copyQueue);arrQueue&operator=(const arrQueue<Type>& otherQueue);voidinitializeQueue();void destroyQueue();bool isQueueEmpty();bool isQueueFull();void addQueue(constType& item);void deQueue(Type&deletedItem);private:int maxSize;int rear;int front;Type* list;};template<typename Type>arrQueue<Type>::arrQueue(int nSize=100){if(nSize < 0){nSize = 100;list = newType[nSize];front = 0;rear = 0;maxSize = 100;}else{list = newType[nSize];front = 0;rear = 0;maxSize =nSize;}}template<typename Type>arrQueue<Type>::~arrQueue(){if(!list){delete[]list; //注意数组的删除,为delete []list;list = NULL;}}template<typename Type>arrQueue<Type>::arrQueue(const arrQueue<Type>©Queue){maxSize =copyQueue.maxSize;front =copyQueue.front;rear = copyQueue.rear;list = newType[maxSize]; //注意需要自定义大小,容易出错.for( int i = 0; i <rear; i++){list[i] =copyQueue.list[i];}}template<typename Type>arrQueue<Type>& arrQueue<Type>::operator=(constarrQueue<Type>& otherQueue){if(this ==&otherQueue){cout <<"can't copy oneSelf!" << endl;return *this;}else{if(maxSize !=otherQueue.maxSize){cout<< "The Size of two Queue are not equal!" << endl;return*this;}else{maxSize= otherQueue.maxSize;front =otherQueue.front;rear =otherQueue.rear;for( inti = 0; i < rear; i++){list[i]= otherQueue.list[i]; }//endforreturn*this;}}//end else}template<typename Type>void arrQueue<Type>::initializeQueue(){destroyQueue();}template<typename Type>void arrQueue<Type>::destroyQueue(){front = 0;rear = 0;}//栈空的判定标志rear==front[初始]template<typename Type>bool arrQueue<Type>::isQueueEmpty(){return (rear ==front);}//空余1位作为判定位,可以把存储结构想象成环!//注意栈满的判定:1.保证空间都被占用;//2.保证rear的下一个位置=front即为满。

顺序表的基本操作【c语言】【创建、插入、删除、输出】

顺序表的基本操作【c语言】【创建、插入、删除、输出】

顺序表的基本操作【c语⾔】【创建、插⼊、删除、输出】作为数据结构初学者,上课时对⼀些知识点掌握得不是很透彻,所以利⽤课余时间通过微博平台总结所学知识,加深对知识的见解,记录学习历程便于后需要时参考。

1 #include<stdio.h>2 #include<malloc.h>3#define OK 14#define ERROR 05#define LIST_INIT_SIZE 1006#define LISTINCREMENT 107#define ElemType int顺序表的基本操作之结构体的创建:1 typedef struct2 {3int *elem;//存储空间基址,也就是该数据得到的内存分配的起始地址4int length;//当前长度5int listsize;//当前分配的存储容量6 } SqList;构造⼀个空的线性表:int InitList_Sq(SqList &L) //&此符号不是c语⾔⾥的取地址符号,⽽是C++⾥的引⽤符号,⽤法为为主函数⾥的T,取⼀个别名,这样⼦对L操作即相当于对T操作{// 该线性表预定义⼤⼩为LIST_INIT_SIZEL.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//ElemType即为intif(!L.elem) return0;//malloc返回值为void*,void* 类型可以强制转换为任何其它类型的指针,在这⾥L.elem为⾮零。

L.length=0;L.listsize=LIST_INIT_SIZE;//LIST_INIT_SIZE=100return OK;}在顺序线性表L中第i个位置之前插⼊新的元素e:1int ListInsert_Sq(SqList &L,int i,int e)2 {3int *newbase;//声明整型指针变量4int *q,*p;5if(i<1||i>L.length+1) return ERROR;//判断i值是否合法,1<i<L.length+16if(L.length>=L.listsize)//判断当前长度是否⼤于当前的存储容量,如果⼤于,则增加LISTINCREMENT长度,即107 {8 newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));9if(!newbase) return0;10 L.elem=newbase;11 L.listsize+=LISTINCREMENT;12 }13 q=&(L.elem[i-1]);//把插⼊位置的地址赋值给q14for(p=&(L.elem[L.length-1]); p>=q; p--)15 *(p+1)=*p;//把i后⾯的元素都向后移⼀位16 *q=e;//在i位置插⼊e17 ++L.length;//长度增加18return OK;19 }在顺序线性表L中删除第i个位置的元素,并⽤e返回其值:int ListDelete_Sq(SqList &L,int i, int &e){// i的合法值为1≤i≤L.lengthint *p;int *q;if(i<1||i>L.length) return ERROR;p=&(L.elem[i-1]);//把i位置的地址赋值给pe=*p;//把i位置的值赋值给eq=L.elem+L.length-1;for(++p; p<=q; ++p)*(p-1)=*p;//i后⾯的元素向前移⼀位,直接覆盖i位置的值--L.length;//长度减少return OK;}顺序表基本操作之输出:int Load_Sq(SqList &L){// 输出顺序表中的所有元素int i;if(L.length==0) printf("The List is empty!");else{printf("The List is: ");for( i=0; i<L.length; i++) printf("%d ",L.elem[i]); // 请填空}printf("\n");return OK;}下⾯是主函数:1int main()2 {3 SqList T;4int a, i;5 ElemType e, x;6if(InitList_Sq(T)) // 判断顺序表是否创建成功7 {8 printf("A Sequence List Has Created.\n");9 }10while(1)11 {12 printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");13 scanf("%d",&a);14switch(a)15 {16case1:17 scanf("%d%d",&i,&x);18if(!ListInsert_Sq(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法19else printf("The Element %d is Successfully Inserted!\n", x);20break;21case2:22 scanf("%d",&i);23if(!ListDelete_Sq(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法24else printf("The Element %d is Successfully Deleted!\n", e);25break;26case3:27 Load_Sq(T);28break;29case0:30return1;31 }32 }33 }。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
struct LNode *next;
}LNode ,*LinkList;
typedef LinkList QueuePtr;
typedef struct{
QueuePtr front;
QueuePtr rear;
}LinkQueue;
void InitQueue_L(LinkQueue &Q)
{//构造一个只有头结点的空队列Q
{
//若队列不为空则用e返回Q的队头元素并返回TRUE,;否则返回FALSE
if(Q.front==Q.rear)return FALSE;
QueuePtr p=Q.front->next;
e=p->data;
return TRUE;
}//QetHead
void EnQueue_L(LinkQueue &Q,QElemType e)
{
//插入元素e为链队列Q中新的队尾元素
LinkList p;
p=new LNode;
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
}//EnQueue_L
bool DeQueue_L(LinkQueue &Q,QElemType &e)
{
//若队ห้องสมุดไป่ตู้不空,则删除Q的对头元素,用e返回其值,并返回TRUE;否则返回FALSE
if(DeQueue_L(Q,e)){cout<<"删除队头元素e,链队列为:";QueueTraverse_L(Q);}
else cout<<"链队列为空"<<endl;
DestroyQueue_L(Q);
}//main
{
//将数组A[]中的元素赋给链队列
for(int i=0;i<n;i++)EnQueue_L(Q,A[i]);
}//QueueCreat_L
void main()
{
int A[]={1,2,3,4,5};
LinkQueue Q;
InitQueue_L(Q);int i=QueueEmpty_L(Q);cout<<i<<endl;
}//QueueEmpty
int QueueLength(LinkQueue Q)
{
//返回Q的元素个数
int k=0;
QueuePtr p;
p=Q.front;
while(p){p=p->next;k++;}
k--;
return k;
}//QueueLength
bool GetHead(LinkQueue Q,QElemType &e)
Q.front=Q.rear;
}//while
}// DestroyQueue_L
bool QueueEmpty_L(LinkQueue Q)
{//判断队列是否为空,是则返回TRUE,否则返回FALSE
if(Q.front==Q.rear)return TRUE;
else return FALSE;
if(Q.front==Q.rear)return FALSE;
LinkList p;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)Q.rear=Q.front;//队列中只有一个结点的情况
delete p;
return TRUE;
Q.front=Q.rear=new LNode;
Q.front->next=NULL;
}//InitQueue_L
void DestroyQueue_L(LinkQueue &Q)
{
//销毁链队列结构Q
while(Q.front){
Q.rear=Q.front->next;
delete Q.front;
链队列的基本操作(创建,销毁,查找,删除,插入等)
#include <iostream>
using namespace std;
const bool TRUE=1 ;
const bool FALSE=0;
typedef int QElemType;
typedef struct LNode
{
QElemType data;
}//DeQueue_L
void QueueTraverse_L(LinkQueue Q)
{
//遍历函数
LinkList p;
p=Q.front->next;
while(p)
{
cout<<p->data;
p=p->next;
}
cout<<endl;
}//QueueTraverse_L
void QueueCreat_L(LinkQueue &Q,int A[] ,int n)
QueueCreat_L(Q,A,5);
QueueTraverse_L(Q);cout<<QueueLength(Q)<<endl;
int f;
cout<<GetHead(Q,f)<<endl;
int e=6;
EnQueue_L(Q,e);
cout<<"将元素"<<e<<"插入到队尾后链表队列为:";QueueTraverse_L(Q);
相关文档
最新文档