数据结构C语言版_非循环队列
c语言队列的实现以及操作
c语言队列的实现以及操作摘要: 队列是数据结构中的一种,在实际生活中也有广泛的应用,本文通过介绍c语言的相关基础知识和算法,实现基本的队列结构以及其中的插入,删除,遍历,清空操作。
关键词:C语言;实现;队列;操作队列是数据结构中的一种,它按照先进先出的原则存储数据,可以分为循环队列和非循环队列,本文将结合c语言的基础知识,利用简单的算法实现非循环队列以及其中的插入,删除,遍历,清空操作。
一、实现队列1.声明结构体在使用c语言实现队列时,首先需要声明一个结构体Queue来定义队列,并定义队头和队尾指针,表示队列的入口和出口,以及空间的大小容量maxSize,并且用一个数组data[]来存储数据。
struct Queue{int data[maxSize]; //存储数据int front; //队头int rear; //队尾int maxSize; //队列容量};2.初始化队列在进行队列操作之前,我们需要将队列初始化,将队头队尾指针置于初始位置,表示队列为空,并将队列最大容量maxSize赋值。
void InitQueue(Queue *queue){queue->front = 0;queue->rear = 0;queue->maxSize = maxSize;}3.入队操作在进行入队操作时,我们先判断队列是否已满,如果未满,就将数据入队,并将队尾指针加一,否则返回队列已满的错误信息。
bool EnQueue(Queue *queue,int data){if((queue->rear+1)%queue->maxSize == queue->front) //队列满return false;queue->data[queue->rear] = data;queue->rear = (queue->rear+1)%queue->maxSize;return true;}4.出队操作在进行出队操作时,我们先判断队列是否为空,如果不为空,就将队头指针对应的数据出队,并将队头指针加一,否则返回队列已空的错误信息。
数据结构实验报告(C语言)(强力推荐)
数据结构实验实验内容和目的:掌握几种基本的数据结构:集合、线性结构、树形结构等在求解实际问题中的应用,以及培养书写规范文档的技巧。
学习基本的查找和排序技术。
让我们在实际上机中具有编制相当规模的程序的能力。
养成一种良好的程序设计风格。
实验教材:数据结构题集(C语言版)清华大学出版社2007年实验项目:实验一、栈和循环队列㈠、实验内容:①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等,栈的顺序存储结构和链式存储结构,以便在实际问题背景下灵活应用。
本程序采用的是链栈结构,具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。
②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,学会循环队列的实现,以便在实际问题背景下灵活运用。
本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。
㈡、实验代码①栈程序代码:#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果:②循环队列程序代码:#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为:\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为:\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果:实验二、数组㈠、实验内容:数组一般不做插入或删除操作,也就是说,一旦建立了数组,则结构中的数据元素个数和元素之间的关系就不再发生变动。
数据结构c语言循环队列定义
数据结构c语言循环队列定义1. 引言在程序设计中,经常需要使用队列这种数据结构。
队列是一种先进先出(First In First Out, FIF)的数据结构,类似于排队买票或取快餐的过程,先到先服务。
相比于其他数据结构,队列的操作比较简单,也容易理解和实现。
本文将介绍一种常见的队列类型——循环队列,并使用c语言实现。
2. 循环队列的定义循环队列是一种特殊的队列类型,它在数组的基础上实现。
其实现方式是将数组的首尾相连,形成一个环状。
这样在操作队列时,当往队列中添加元素时,如果队列尾指针到达数组末尾,则在数组头部继续添加元素。
当从队列中删除元素时,如果队列头指针到达数组末尾,则在数组头部继续删除元素。
这样循环下去,队列就具有了循环的特性,即循环队列。
3. 循环队列c语言实现由于循环队列是在数组的基础上实现的,因此我们定义一个数组来存储队列元素,再定义队列头和队列尾指针来指向队列中的首尾元素。
具体c语言实现如下:```define MAXSIZE 100 // 队列最大容量typedef int ElemType; // 元素类型定义typedef struct {ElemType data[MAXSIZE]; // 存储元素的数组int front; // 队列头指针int rear; // 队列尾指针} CircleQueue;// 初始化循环队列void InitQueue(CircleQueue *q) {q->front = q->rear = 0; // 头尾指针初始化为0 }// 判断循环队列是否为空bool IsEmpty(CircleQueue *q) {return q->front == q->rear;}// 判断循环队列是否为满bool IsFull(CircleQueue *q) {return (q->rear + 1) % MAXSIZE == q->front;}// 入队操作bool EnQueue(CircleQueue *q, ElemType e) {// 队列已满,无法添加元素if (IsFull(q)) {return false;}q->data[q->rear] = e; // 将元素添加到队列尾部q->rear = (q->rear + 1) % MAXSIZE; // 队列尾指针后移一位return true;}// 出队操作bool DeQueue(CircleQueue *q, ElemType *e) {// 队列为空,无法删除元素if (IsEmpty(q)) {return false;}*e = q->data[q->front]; // 将队列头部元素取出q->front = (q->front + 1) % MAXSIZE; // 队列头指针后移一位return true;}```以上是循环队列的c语言实现,可以通过以上函数对循环队列进行初始化、判断队列是否为空或是否为满,入队和出队操作。
研究生入学考试《电子技术基础》考试大纲
2022年研究生入学考试自命题科目考试大纲科目代码:903 科目名称:计算机综合一、参考书目1.《数据结构(C语言版)第二版》严蔚敏主编,人民邮电出版社,2015;2.《计算机网络》(第7版),谢希仁,电子工业出版社,2017;3.《Computer Networking: A Top Down Approach》, James F. Kurose and Keith W. Rose(陈鸣译), 机械工业出版社, 2017。
二、考试内容及要求(一)数据结构1.绪论考试内容:数据结构,抽象数据类型,时间复杂度,空间复杂度。
考试要求:了解《数据结构》的研究内容,数据结构的基本概念和术语,熟悉抽象数据类型的表示与实现,掌握算法的时间复杂度的计算方法。
2.线性表考试内容:线性表的类型定义、顺序表示和实现、链式表示和实现,线性表在一元多项式相加中的应用。
考试要求:(1)了解线性表的逻辑结构特性,线性表的两种存储实现方式和描述方法。
(2)掌握顺序表的定义与实现,包括查找、插入、删除算法的实现。
(3)掌握在各种链式结构中实现线性表操作的基本方法,能在实际应用中选用适当的链表结构。
(4)能够从时间和空间复杂度的角度综合比较线性表两种存储结构的不同特点及其适用场合。
(5)了解线性表在一元多项式相加中的应用。
3.栈和队列考试内容:栈的定义、表示和实现,队列的定义、表示和实现,栈的应用,栈与递归的实现。
考试要求:(1)了解栈和队列的定义、特性,并能正确应用它们解决实际问题。
(2)掌握栈的顺序表示、链式表示以及相应操作的实现。
注意栈空和栈满的条件。
(3)掌握队列的顺序表示、链式表示以及相应操作的实现。
注意循环队列中队头与队尾指针的变化情况。
(4)了解栈与递归的实现。
4.串考试内容:串的类型定义,串的表示和实现,串的模式匹配算法。
考试要求:(1)了解串的定义、基本操作。
(2)掌握顺序存储结构上串各种操作的方法。
(3)掌握KMP算法。
数据结构(C语言版)(第2版)课后习题答案
数据结构(C语言版)(第2版)课后习题答案李冬梅目录第1章绪论...................................................................................... 错误!未定义书签。
第2章线性表 .................................................................................. 错误!未定义书签。
第3章栈和队列 .............................................................................. 错误!未定义书签。
第4章串、数组和广义表 ............................................................... 错误!未定义书签。
第5章树和二叉树 .......................................................................... 错误!未定义书签。
第6章图 ........................................................................................... 错误!未定义书签。
第7章查找...................................................................................... 错误!未定义书签。
第8章排序...................................................................................... 错误!未定义书签。
第1章绪论1.简述下列概念:数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。
数据结构(C语言版)
比较
Prim算法适用于稠密图, Kruskal算法适用于稀疏图;
两者时间复杂度相近,但 Kruskal算法需额外处理并查
集数据结构。
最短路径算法设计思想及实现方法比较
1 2
Dijkstra算法
从源点出发,每次找到距离源点最近的顶点并更 新距离值,直至所有顶点距离确定。适用于不含 负权边的图。
Floyd算法
特殊二叉树
满二叉树、完全二叉树等。
二叉树的遍历与线索化
二叉树的遍历
前序遍历、中序遍历、后序遍历和层 次遍历是二叉树的四种基本遍历方法 。
线索化二叉树
为了方便查找二叉树节点的前驱和后 继,可以对二叉树进行线索化处理, 即在节点的空指针域中存放指向前驱 或后继的指针。
树和森林的遍历与转换
树的遍历
01
串的顺序存储结构
01
02
03
串的顺序存储结构是用 一组地址连续的存储单 元来存储串中的字符序
列的。
按照预定义的大小,为 每个定义的串变量分配 一个固定长度的存储区 ,一般是用定长数组来
定义。
串值的存储:将实际串 长度值保存在数组的0下 标位置,串的字符序列 依次存放在从1开始的数
组元素中。
串的链式存储结构
03
比较
DFS空间复杂度较低,适用于递 归实现;BFS可找到最短路径, 适用于非递归实现。
最小生成树算法设计思想及实现方法比较
Prim算法
从某一顶点开始,每次选择当 前生成树与外界最近的边加入 生成树中,直至所有顶点加入
。
Kruskal算法
按边权值从小到大排序,依次 选择边加入生成树中,保证不
形成环路。
数据结构(C语言版)
c语言队列数据结构
c语言队列数据结构队列是一种常见的数据结构,它遵循先进先出(FIFO)的原则。
在C语言中,我们可以使用数组或链表来实现队列数据结构。
本文将介绍C语言中队列的实现方法及其应用。
一、数组实现队列数组是一种简单且常用的数据结构,可以用来实现队列。
在C语言中,我们可以使用数组来创建一个固定大小的队列。
下面是一个使用数组实现队列的示例代码:```c#include <stdio.h>#define MAX_SIZE 100int queue[MAX_SIZE];int front = -1;int rear = -1;void enqueue(int data) {if (rear == MAX_SIZE - 1) {printf("队列已满,无法插入元素。
\n");return;}if (front == -1) {front = 0;}rear++;queue[rear] = data;}void dequeue() {if (front == -1 || front > rear) {printf("队列为空,无法删除元素。
\n"); return;}front++;}int getFront() {if (front == -1 || front > rear) {printf("队列为空。
\n");return -1;}return queue[front];}int isEmpty() {if (front == -1 || front > rear) {return 1;}return 0;}int main() {enqueue(1);enqueue(2);enqueue(3);printf("队列的第一个元素:%d\n", getFront());dequeue();printf("队列的第一个元素:%d\n", getFront());return 0;}```在上述代码中,我们使用了一个数组`queue`来存储队列的元素。
数据结构(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. 单链表单链表是一种常见的链式存储结构,每个节点包含数据和指向下一个节点的指针。
数据结构(c语言版)课后习题答案完整版
【解答】
循环队列类定义
#include<assert.h>
template <class Type> classQueue{//循环队列的类定义
public:
Queue(int=10 );
~Queue( ){ delete[ ]Q;}
voidEnQueue(Type&item);
TypeDeQueue();
根据提示,算法可设计为:
//以下为顺序栈的存储结构定义
#define StackSize 100 //假定预分配的栈空间最多为100个元素
typedef char DataType;//假定栈元素的数据类型为字符
typedef struct{
DataType data[StackSize];
int top;
}//算法结束。
第
1.选择题
ADDCA CCBDC CCACC
2.应用题
(2)设一棵二叉树的先序序列:A B D F C E G H,中序序列:B F D A G E H C
画出这棵二叉树。
画出这棵二叉树的后序线索树。
将这棵二叉树转换成对应的树(或森林)。
(1) (2)
(3)假设用于通信的电文仅由8个字母组成,字母在电文中出现的频率分别为0.07,0.19,0.02,0.06,0.32,0.03,0.21,0.10。
数据结构的实训报告结果
一、实训目的本次数据结构实训旨在通过实践操作,加深对数据结构理论知识的理解,提高解决实际问题的能力。
通过实训,使学生能够熟练掌握各种基本数据结构及其操作方法,并能够将这些知识应用于解决实际问题。
二、实训环境1. 操作系统:Windows 102. 编程语言:C语言3. 开发环境:Visual Studio 20194. 实训教材:《数据结构》(C语言版)三、实训内容本次实训主要内容包括线性表、栈、队列、树、图等基本数据结构的创建、操作和应用。
1. 线性表(1)单链表的创建、插入、删除和查找操作(2)双向链表的创建、插入、删除和查找操作(3)循环链表的创建、插入、删除和查找操作2. 栈(1)栈的创建、入栈、出栈和判断栈空操作(2)应用栈实现括号匹配3. 队列(1)队列的创建、入队、出队和判断队列空操作(2)应用队列实现广度优先搜索4. 树(1)二叉树的创建、插入、删除和遍历操作(2)二叉查找树的创建、插入、删除和查找操作5. 图(1)图的创建、添加边、删除边和遍历操作(2)图的深度优先遍历和广度优先遍历四、实训过程1. 线性表首先,我们学习了单链表、双向链表和循环链表的基本概念和创建方法。
通过编写代码,实现了链表的插入、删除和查找操作。
在实训过程中,我们遇到了一些问题,如链表插入操作时指针的移动、删除操作时避免内存泄漏等。
通过查阅资料和与同学讨论,我们逐步解决了这些问题。
2. 栈接着,我们学习了栈的基本概念和操作方法。
通过编写代码,实现了栈的创建、入栈、出栈和判断栈空操作。
在实训过程中,我们遇到了栈空和栈满的情况,通过设置标志位和循环队列的方法解决了这些问题。
此外,我们还学习了应用栈实现括号匹配,加深了对栈的应用理解。
3. 队列然后,我们学习了队列的基本概念和操作方法。
通过编写代码,实现了队列的创建、入队、出队和判断队列空操作。
在实训过程中,我们遇到了队列空和队列满的情况,通过设置标志位和循环队列的方法解决了这些问题。
数据结构(C语言版)严蔚敏课后习题答案
数据结构(C语言版)严蔚敏课后习题答案数据结构(C语言版)严蔚敏课后习题答案一、线性表1. 顺序表顺序表是一种存储结构,它将元素顺序存放在一块连续的存储区域中。
C语言中常用数组来实现顺序表。
以下是一些常见题目的解答:题目1:已知顺序表中存储了n个整数,请编写一个算法,将这个顺序表中的所有负数挑选出来,并将它们按照原有顺序存放在新的顺序表中。
解答:```#include <stdio.h>#define MAX_SIZE 100int main() {int A[MAX_SIZE], neg[MAX_SIZE];int n, i, j = 0;printf("Enter the number of elements: ");scanf("%d", &n);printf("Enter the elements: ");for (i = 0; i < n; i++) {scanf("%d", &A[i]);if (A[i] < 0) {neg[j] = A[i];j++;}}printf("Negative numbers: ");for (i = 0; i < j; i++) {printf("%d ", neg[i]);}return 0;}```题目2:假设顺序表A和B中的元素递增有序排列,编写一个算法合并这两个顺序表,并使合并后的顺序表仍然递增有序。
解答:```#include <stdio.h>#define MAX_SIZE 100int main() {int A[MAX_SIZE], B[MAX_SIZE], C[MAX_SIZE * 2]; int m, n, i, j, k;printf("Enter the number of elements in the first list: "); scanf("%d", &m);printf("Enter the elements in increasing order: ");for (i = 0; i < m; i++) {scanf("%d", &A[i]);C[i] = A[i];}printf("Enter the number of elements in the second list: "); scanf("%d", &n);printf("Enter the elements in increasing order: ");for (i = 0; i < n; i++) {scanf("%d", &B[i]);C[m + i] = B[i];}// Merge A and B into Ci = j = k = 0;while (i < m && j < n) { if (A[i] < B[j]) {C[k] = A[i];i++;} else {C[k] = B[j];j++;}k++;}while (i < m) {C[k] = A[i];i++;k++;}while (j < n) {C[k] = B[j];j++;k++;}printf("Merged list in increasing order: ");for (i = 0; i < m + n; i++) {printf("%d ", C[i]);}return 0;}```2. 链表链表是一种动态的数据结构,它通过结点之间的指针联系起来。
《数据结构》学习指导
《数据结构》学习指导说明:本指导以《数据结构》(C语言版)(严蔚敏等编著,清华大学出版社1997年出版,国家级优秀教材特等奖)和《数据结构题集》(严蔚敏等编著,清华大学出版社1999年出版)为教学主要参考书。
一、绪论1、学习目的:明确数据结构课程在本专业知识结构中的地位,作用。
课程的特点,教学的要求,方法。
明确数据结构所研究的问题以及有关基本概念。
初步掌握抽象数据类型的表示与实现,初步明确算法分析的作用与分析的重点,初步掌握算法分析的方法。
2、学习重点:数据的逻辑结构、存储结构及其算法,数据结构的有关概念,抽象数据类型及其表示与实现,算法,算法设计的要求,算法的时间复杂度和算法的空间复杂度。
3、学习难点:数据结构的有关概念,抽象数据类型的表示与实现;算法的时间复杂度分析。
4、课程内容与基本要求(一) 数据结构的引入(1) 三个世界:现实世界,信息世界,机器世界。
数据结构要解决的就是实现从现实世界到信息世界,再由信息世界到机器世界的转换,从而实现用计算机来解决问题的目的。
(2) 非数值问题(结合三个世界讲):控制,管理,数据处理(3) 数值问题:数值计算(4)数据结构:从学科角度讲,数据结构是一门研究非数值计算的程序设计问题中计算机操作对象以及他们之间的关系和操作等等的学科。
(二) 课程的地位,性质,作用。
(1) 地位: 计算机专业的核心课程之一。
(2) 性质: 算法理论基础和软件设计的技术基础课。
(3) 作用: 程序设计的基础,编译程序,操作系统,数据库系统及软件系统和应用程序的基础(三) 数据结构的产生和发展(四) 课程的特点,学习的要求教材:《数据结构》(C语言版)严蔚敏等编著北京清华大学出版社1997年参考书:《数据结构》许卓群等编著北京高等教育出版社1987年数据结构实用教程》(C/C++描述)徐孝凯北京清华大学出版社1999年《数据结构题集》严蔚敏等编著北京清华大学出版社1999年《数据结构导学》苏光奎等编著北京清华大学出版社20XX年《数据结构》(C语言篇)-习题与解析李春葆编著北京清华大学出版社20XX年《数据结构》实验指导书唐开山自编讲义20XX年(五) 基本概念和术语数据数据元素数据对象(4)数据结构:按某种逻辑关系组织起来的一批数据,按一定的存储表示方式把它存储到计算机的存储器中,并在这些数据上定义了一个运算的集合,叫做一个数据结构。
队列的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指针。
数据结构C语言版 实验报告
数据结构C语言版实验报告《数据结构 C 语言版实验报告》一、实验目的本次实验旨在通过使用 C 语言实现常见的数据结构,加深对数据结构基本概念和操作的理解,提高编程能力和问题解决能力。
二、实验环境操作系统:Windows 10编程环境:Visual Studio 2019三、实验内容1、线性表顺序表的实现链表的实现(包括单向链表、双向链表)2、栈和队列栈的实现(顺序栈、链栈)队列的实现(顺序队列、循环队列、链队列)3、数组和字符串数组的基本操作字符串的操作(字符串的存储、字符串的比较、字符串的连接等)4、树和二叉树二叉树的遍历(前序、中序、后序)二叉树的创建和基本操作5、图图的存储(邻接矩阵、邻接表)图的遍历(深度优先遍历、广度优先遍历)四、实验步骤1、线性表顺序表的实现定义顺序表的数据结构,包括数组和表的长度等。
实现顺序表的初始化、插入、删除、查找等操作。
编写测试程序,对顺序表的各种操作进行测试。
链表的实现定义单向链表和双向链表的数据结构,包括节点结构体。
实现链表的创建、插入、删除、查找等操作。
编写测试程序,验证链表操作的正确性。
栈的实现定义顺序栈和链栈的数据结构。
实现栈的入栈、出栈、栈顶元素获取等操作。
进行栈的操作测试。
队列的实现定义顺序队列、循环队列和链队列的数据结构。
实现队列的入队、出队、队头队尾元素获取等操作。
对队列的操作进行测试。
3、数组和字符串数组的操作实现数组的初始化、元素访问、数组元素的修改等。
测试数组的基本操作。
字符串的操作定义字符串的存储方式。
实现字符串的比较、连接、复制等操作。
编写测试用例,验证字符串操作的准确性。
二叉树的遍历采用递归方式实现二叉树的前序、中序、后序遍历。
输出遍历结果进行验证。
二叉树的创建和基本操作构建二叉树的数据结构。
实现二叉树的节点插入、删除等操作。
5、图图的存储分别用邻接矩阵和邻接表来存储图。
实现图的初始化操作。
图的遍历用深度优先遍历和广度优先遍历算法对图进行遍历。
数据结构(C语言版)考研复习题
数据结构(C语言版)考研复习题第1 页共19 页第一章绪论1.1 简述下列概念:数据、数据元素、数据类型、数据结构、逻辑结构、存储结构、线性结构、非线性结构。
1.2 常用的存储表示方法有哪几种?1.3 算法的时间复杂度仅与问题的规模相关吗?1.4 有时为了比较两个同数量级算法的优劣,须突出主项的常数因子,而将低次项用大"O"记号表示。
例如,设T1(n)=1.39nlgn+100n+256=1.39nlgn+O(n), T2(n)=2.0nlgn-2n=2.0lgn+O(n), 这两个式子表示,当n足够大时T1(n)优于T2(n),因为前者的常数因子小于后者。
请用此方法表示下列函数,并指出当n足够大时,哪一个较优,哪一个较劣?函数大"O"表示优劣(1) T1(n)=5n22-3n+60lgn 5n22+O(n)(2) T2(n)=3n22+1000n+3lgn 3n22+O(n)(3) T3(n)=8n22+3lgn 8n22+O(lgn)(4) T4(n)=1.5n2+6000nlgn 1.5n2+O(nlgn)第二章线性表2.1 试描述头指针、头结点、开始结点的区别、并说明头指针和头结点的作用。
2.2 何时选用顺序表、何时选用链表作为线性表的存储结构为宜?2.3 为什么在单循环链表中设置尾指针比设置头指针更好?2.4 下述算法的功能是什么?LinkList Demo(LinkList L){ // L 是无头结点单链表ListNode *Q,*P;if(L&&L->next){Q=L;L=L->next;P=L;while (P->next) P=P->next;P->next=Q; Q->next=NULL;}return L;}// Demo2.5设线性表的n个结点定义为(a0,a1,...a n-1),重写顺序表上实现的插入和删除算法:InsertList 和DeleteList.2.6 设顺序表L是一个递减有序表,试写一算法,将x插入其后仍保持L的有序性。
数据结构:循环队列(C语言实现)
数据结构:循环队列(C语言实现)生活中有很多队列的影子,比如打饭排队,买火车票排队问题等,可以说与时间相关的问题,一般都会涉及到队列问题;从生活中,可以抽象出队列的概念,队列就是一个能够实现“先进先出”的存储结构。
队列分为链式队列和静态队列;静态队列一般用数组来实现,但此时的队列必须是循环队列,否则会造成巨大的内存浪费;链式队列是用链表来实现队列的。
这里讲的是循环队列,首先我们必须明白下面几个问题一、循环队列的基础知识1.循环队列需要几个参数来确定循环队列需要2个参数,front和rear2.循环队列各个参数的含义(1)队列初始化时,front和rear值都为零;(2)当队列不为空时,front指向队列的第一个元素,rear指向队列最后一个元素的下一个位置;(3)当队列为空时,front与rear的值相等,但不一定为零;3.循环队列入队的伪算法(1)把值存在rear所在的位置;(2)rear=(rear+1)%maxsize ,其中maxsize代表数组的长度;程序代码:[cpp]view plaincopy1.bool Enqueue(PQUEUE Q, int val)2.{3.if(FullQueue(Q))4.return false;5.else6. {7. Q->pBase[Q->rear]=val;8. Q->rear=(Q->rear+1)%Q->maxsize;9.return true;10. }11.}4.循环队列出队的伪算法(1)先保存出队的值;(2)front=(front+1)%maxsize ,其中maxsize代表数组的长度;程序代码:[cpp]view plaincopy1.bool Dequeue(PQUEUE Q, int *val)2.{3.if(EmptyQueue(Q))4. {5.return false;6. }7.else8. {9. *val=Q->pBase[Q->front];10. Q->front=(Q->front+1)%Q->maxsize;11.return true;12. }13.}5.如何判断循环队列是否为空if(front==rear)队列空;else队列不空;[cpp]view plaincopy1.bool EmptyQueue(PQUEUE Q)2.{3.if(Q->front==Q->rear) //判断是否为空4.return true;5.else6.return false;7.}6.如何判断循环队列是否为满这个问题比较复杂,假设数组的存数空间为7,此时已经存放1,a,5,7,22,90六个元素了,如果在往数组中添加一个元素,则rear=front;此时,队列满与队列空的判断条件front=rear相同,这样的话我们就不能判断队列到底是空还是满了;解决这个问题有两个办法:一是增加一个参数,用来记录数组中当前元素的个数;第二个办法是,少用一个存储空间,也就是数组的最后一个存数空间不用,当(rear+1)%maxsiz=front时,队列满;[cpp]view plaincopy1.bool FullQueue(PQUEUE Q)2.{3.if(Q->front==(Q->rear+1)%Q->maxsize) //判断循环链表是否满,留一个预留空间不用4.return true;5.else6.return false;7.}附录:queue.h文件代码:[cpp]view plaincopy1.#ifndef __QUEUE_H_2.#define __QUEUE_H_3.typedef struct queue4.{5.int *pBase;6.int front; //指向队列第一个元素7.int rear; //指向队列最后一个元素的下一个元素8.int maxsize; //循环队列的最大存储空间9.}QUEUE,*PQUEUE;10.11.void CreateQueue(PQUEUE Q,int maxsize);12.void TraverseQueue(PQUEUE Q);13.bool FullQueue(PQUEUE Q);14.bool EmptyQueue(PQUEUE Q);15.bool Enqueue(PQUEUE Q, int val);16.bool Dequeue(PQUEUE Q, int *val);17.#endifqueue.c文件代码:[cpp]view plaincopy1.#include<stdio.h>2.#include<stdlib.h>3.#include"malloc.h"4.#include"queue.h"5./***********************************************6.Function: Create a empty stack;7.************************************************/8.void CreateQueue(PQUEUE Q,int maxsize)9.{10. Q->pBase=(int *)malloc(sizeof(int)*maxsize);11.if(NULL==Q->pBase)12. {13. printf("Memory allocation failure");14. exit(-1); //退出程序15. }16. Q->front=0; //初始化参数17. Q->rear=0;18. Q->maxsize=maxsize;19.}20./***********************************************21.Function: Print the stack element;22.************************************************/23.void TraverseQueue(PQUEUE Q)24.{25.int i=Q->front;26. printf("队中的元素是:\n");27.while(i%Q->maxsize!=Q->rear)28. {29. printf("%d ",Q->pBase[i]);30. i++;31. }32. printf("\n");33.}34.bool FullQueue(PQUEUE Q)35.{36.if(Q->front==(Q->rear+1)%Q->maxsize) //判断循环链表是否满,留一个预留空间不用37.return true;38.else39.return false;40.}41.bool EmptyQueue(PQUEUE Q)42.{43.if(Q->front==Q->rear) //判断是否为空44.return true;45.else46.return false;47.}48.bool Enqueue(PQUEUE Q, int val)49.{50.if(FullQueue(Q))51.return false;52.else53. {54. Q->pBase[Q->rear]=val;55. Q->rear=(Q->rear+1)%Q->maxsize;56.return true;57. }58.}59.60.bool Dequeue(PQUEUE Q, int *val)61.{62.if(EmptyQueue(Q))63. {64.return false;65. }66.else67. {68. *val=Q->pBase[Q->front];69. Q->front=(Q->front+1)%Q->maxsize;70.return true;71. }72.}[文档可能无法思考全面,请浏览后下载,另外祝您生活愉快,工作顺利,万事如意!]。
数据结构(C语言版本)
数据结构的形式定义:数据结构是一个二元组 data_structure=(D,S)
其中:D是数据元素的有限集,S是D上关系的有限集。
2023/11/3
例1 一种结构 lineority=(K,R) K={k1,k2,kHale Waihona Puke ,k4,k5,k6,k7} R={r}
• 众所周知,二十世纪四十年代,电子数字计算机问世的直接原因是解
决弹道学的计算问题。早期,电子计算机的应用范围,几乎只局限于 科学和工程的计算,其处理的对象是纯数值性的信息,通常,人们把 这类问题称为数值计算。
• 近三十年来,电子计算机的发展异常迅猛,这不仅表现在计算机本身
运算速度不断提高、信息存储量日益扩大、价格逐步下降,更重要的 是计算机广泛地应用于情报检索、企业管理、系统工程等方面,已远 远超出了科技计算的范围,而渗透到人类社会活动的一切领域。与此 相应,计算机的处理对象也从简单的纯数值性信息发展到非数值性的 和具有一定结构的信息。
4.存储结构
• 数据在计算机中的存储表示称为数据的存储结构。 • 在表1-1所示的表格数据在计算机中可以有多种存储表示,例如,
可以表示成数组,存放在内存中;也可以表示成文件,存放在磁 盘上,等等。
2023/11/3
5.数据处理
• 数据处理是指对数据进行查找、插入、删除、合并、排序、统计
以及简单计算等的操作过程。在早期,计算机主要用于科学和工 程计算,进入八十年代以后,计算机主要用于数据处理。据有关 统计资料表明,现在计算机用于数据处理的时间比例达到80%以 上,随着时间的推移和计算机应用的进一步普及,计算机用于数 据处理的时间比例必将进一步增大。
数据结构(C语言版)(第2版)课后习题答案
数据结构(C语言版)(第2版)课后习题答案数据结构(C语言版)(第2版)课后习题答案1. 简介数据结构是计算机科学领域中非常重要的一门学科,它研究的是数据的组织、存储和管理方式。
本文将针对《数据结构(C语言版)(第2版)》的课后习题提供答案,帮助读者更好地理解和应用数据结构。
2. 第一章: 绪论在第一章中,主要介绍了数据结构的基本概念、分类和基本操作。
以下是部分习题的答案:2.1 习题1习题描述:什么是数据结构?答案:数据结构是指数据对象中元素之间的关系,以及对这些关系进行操作的方法和技术的集合。
2.2 习题2习题描述:数据结构的分类有哪些?答案:数据结构可以分为线性结构和非线性结构。
线性结构包括线性表、栈、队列等;非线性结构包括树、图等。
3. 第二章: 线性表第二章介绍了线性表的定义、分类和实现。
以下是部分习题的答案:3.1 习题1习题描述:什么是线性表?答案:线性表是由n个数据元素a1, a2, ..., an组成的有限序列,其中元素之间存在着一一对应的关系。
3.2 习题2习题描述:线性表的分类有哪些?答案:线性表可以分为顺序表和链表。
顺序表是用一段地址连续的存储单元一次存储线性表的所有元素,而链表是采用链式存储结构,通过每个元素存储其后继元素的地址来实现元素之间的逻辑关系。
4. 第三章: 栈与队列第三章讲解了栈和队列的定义、特性和实现。
以下是部分习题的答案:4.1 习题1习题描述:栈和队列有什么区别?答案:栈是一种后进先出的线性表,只能在表尾进行插入和删除操作;队列是一种先进先出的线性表,只能在表的一端进行插入和删除操作。
4.2 习题2习题描述:栈的应用有哪些?答案:栈在计算机科学中有广泛的应用,如函数的调用和返回、括号匹配、表达式求值等。
5. 第四章: 串第四章讲解了串的定义、模式匹配和实现。
以下是部分习题的答案:5.1 习题1习题描述:什么是串?答案:串是由零个或多个字符组成的有限序列,串中的字符个数称为串的长度。
数据结构(C语言版)
数据结构(C语言版) 数据结构(C语言版)1.简介1.1 什么是数据结构1.2 数据结构的作用1.3 数据结构的分类1.4 C语言中的数据结构2.线性表2.1 数组2.2 链表2.2.1 单链表2.2.2 双链表2.2.3 循环链表3.栈与队列3.1 栈3.1.1 栈的定义3.1.2 栈的基本操作3.2 队列3.2.1 队列的定义3.2.2 队列的基本操作4.树4.1 二叉树4.1.1 二叉树的定义4.1.2 二叉树的遍历4.2 AVL树4.3 B树5.图5.1 图的定义5.2 图的存储方式5.2.1 邻接矩阵5.2.2 邻接表5.3 图的遍历算法5.3.1 深度优先搜索(DFS)5.3.2 广度优先搜索(BFS)6.散列表(哈希表)6.1 散列函数6.2 散列表的冲突解决6.2.1 开放寻址法6.2.2 链地质法7.排序算法7.1 冒泡排序7.2 插入排序7.3 选择排序7.4 快速排序7.5 归并排序7.6 堆排序7.7 计数排序7.8 桶排序7.9 基数排序8.算法分析8.1 时间复杂度8.2 空间复杂度8.3 最好、最坏和平均情况分析8.4 大O表示法附件:________无法律名词及注释:________●数据结构:________指数据元素之间的关系,以及对数据元素的操作方法的一种组织形式。
●C语言:________一种通用的编程语言,用于系统软件和应用软件的开发。
●线性表:________由n个具有相同特性的数据元素组成的有限序列。
●栈:________一种特殊的线性表,只能在表的一端插入和删除数据,遵循后进先出(LIFO)的原则。
●队列:________一种特殊的线性表,只能在表的一端插入数据,在另一端删除数据,遵循先进先出(FIFO)的原则。
●树:________由n(n>=0)个有限节点组成的集合,其中有一个称为根节点,除根节点外,每个节点都有且仅有一个父节点。
●图:________由顶点的有穷集合和边的集合组成,通常用G(V, E)表示,其中V表示顶点的有穷非空集合,E表示边的有穷集合。
C语言版数据结构知识点汇总
C语言版数据结构知识点汇总C语言是一种强大的编程语言,广泛应用于数据结构与算法的实现。
掌握C语言版数据结构的知识可以帮助开发人员更好地理解和设计高效的程序。
下面是C语言版数据结构的一些重要知识点的汇总:1. 数组(Array):数组是一种基本的数据结构,用于存储一系列相同类型的元素。
在C语言中,数组是通过下标来访问元素的,数组下标从0开始计数。
2. 链表(Linked List):链表是一种动态数据结构,不需要连续的内存空间。
链表由一系列结点组成,每个结点包含数据和指向下一个结点的指针。
常见的链表有单向链表、双向链表和循环链表。
3. 栈(Stack):栈是一种先进后出(LIFO)的数据结构,只能在末尾进行插入和删除操作。
在C语言中,栈可以用数组或链表来实现。
栈常用于表达式求值、函数调用和递归等场景。
4. 队列(Queue):队列是一种先进先出(FIFO)的数据结构,只能在一端进行插入操作,另一端进行删除操作。
在C语言中,队列可以用数组或链表来实现。
队列常用于广度优先和任务调度等场景。
5. 树(Tree):树是一种非线性的数据结构,由一系列的结点组成,每个结点可以有多个子结点。
树的一些重要特点包括根结点、父结点、子结点、叶子结点和深度等。
常见的树结构有二叉树和二叉树。
6. 图(Graph):图是一种非线性的数据结构,由一组顶点和一组边组成。
图的一些重要概念包括顶点的度、路径、连通性和环等。
图有多种表示方法,包括邻接矩阵和邻接表。
7.查找算法:查找算法用于在数据集中查找特定元素或确定元素是否存在。
常见的查找算法有顺序查找、二分查找和哈希查找。
在C语言中,可以使用数组、链表和树来实现不同的查找算法。
8.排序算法:排序算法用于将数据集中的元素按照特定的顺序进行排列。
常见的排序算法有冒泡排序、插入排序、选择排序、快速排序和归并排序等。
排序算法的选择取决于数据规模、时间复杂度和稳定性等因素。
9. 堆(Heap):堆是一种特殊的树结构,具有如下特点:完全二叉树、最大堆或最小堆的性质。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
return 0;
}
*((*Q).base+(*Q).rear)=e;
(*Q).rear++;
return 1;
}
Байду номын сангаас
// 若队列不空,则删除Q的队头元素,用e返回其值,并返回1,否则返回0
int DeQueue(SqQueue *Q,QElemType *e)
(*Q).base=NULL;
(*Q).front=(*Q).rear=0;
return 1;
}
// 将Q清为空队列
int ClearQueue(SqQueue *Q)
{
(*Q).front=(*Q).rear=0;
return 1;
}
// 若队列Q为空队列,则返回1,否则返回0
*/
printf("现在队列空否?%u(1:空 0:否)\n",QueueEmpty(Q));
printf("现在队列中的元素为: \n");
QueueTraverse(Q,visit);
DeQueue(&Q,&d);
printf("删除队头元素%d\n",d);
printf("队列中的元素为: \n");
printf("请输入队列元素个数n: ");
scanf("%d",&n);
printf("请输入%d个整型队列元素:\n",n);
for(i=0;i<n;i++)
{
scanf("%d",&d);
EnQueue(&Q,d);
}
printf("队列长度为:%d\n",QueueLength(Q));
队列长度为:0
请输入队列元素个数n: 3
请输入3个整型队列元素:
1 2 3
队列长度为:3
现在队列空否?0(1:空 0:否)
现在队列中的元素为:
1 2 3
删除队头元素1
队列中的元素为:
2 3
队头元素为: 2
清空队列后, 队列空否?1(1:空 0:否)
无队头元素(空队列)
请按任意键继续. . .
QueueTraverse(Q,visit);
j=GetHead(Q,&d);
if(j)
printf("队头元素为: %d\n",d);
else
printf("无队头元素(空队列)\n");
ClearQueue(&Q);
printf("清空队列后, 队列空否?%u(1:空 0:否)\n",QueueEmpty(Q));
{
int j;
int i,n;
QElemType d;
SqQueue Q;
InitQueue(&Q);
printf("初始化队列后,队列空否?%u(1:空 0:否)\n",QueueEmpty(Q));
printf("队列长度为:%d\n",QueueLength(Q));
/*
数据结构C语言版 非循环队列
编译环境:Dev-C++ 4.9.9.2
日期: 2011年2月12日
*/
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef int QElemType;
// 顺序队列(非循环,因为是非循环的,所以需要判断是否溢出
}
// 若队列不空,则用e返回Q的队头元素,并返回1,否则返回0
int GetHead(SqQueue Q,QElemType *e)
{
if(Q.front==Q.rear) // 队列空
return 0;
*e=*(Q.base+Q.front);
return 1;
}
{
int i;
i=Q.front;
while(i!=Q.rear)
{
vi(*(Q.base+i));
i++;
}
printf("\n");
return 1;
}
void visit(QElemType i)
{
printf("%d ",i);
}
int main()
j=GetHead(Q,&d);
if(j)
printf("队头元素为: %d\n",d);
else
printf("无队头元素(空队列)\n");
DestroyQueue(&Q);
system("pause");
return 0;
}
/*
输出效果:
初始化队列后,队列空否?1(1:空 0:否)
if(!(*Q).base) // 存储分配失败
exit(0);
(*Q).front=(*Q).rear=0; //初始化下标
return 1;
}
// 销毁队列Q,Q不再存在
int DestroyQueue(SqQueue *Q)
{
if((*Q).base)
free((*Q).base);
{
if((*Q).front==(*Q).rear) // 队列空
return 0;
*e=(*Q).base[(*Q).front];
(*Q).front=(*Q).front+1;
return 1;
}
// 从队头到队尾依次对队列Q中每个元素调用函数vi()
int QueueTraverse(SqQueue Q,void(*vi)(QElemType))
// 尾指针,若队列不空,指向队列尾元素的下一个位置 相当于一个数组下标
int rear;
}SqQueue;
// 构造一个空队列Q
int InitQueue(SqQueue *Q)
{
//分配定长的空间,相当于一个数组
(*Q).base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
#define MAXQSIZE 5 // 最大队列长度(对于循环队列,最大队列长度要减1)
typedef struct
{
QElemType *base;// 初始化的动态分配存储空间 相当于一个数组
// 头指针,若队列不空,指向队列头元素,相当于一个数组下标
int front;
// 插入元素e为Q的新的队尾元素
int EnQueue(SqQueue *Q,QElemType e)
{
if((*Q).rear>=MAXQSIZE)
{ // 队列满,增加1个存储单元
(*Q).base=(QElemType *)realloc((*Q).base,
((*Q).rear+1)*sizeof(QElemType));
int QueueEmpty(SqQueue Q)
{
if(Q.front==Q.rear) // 队列空的标志
return 1;
else
return 0;
}
// 返回Q的元素个数,即队列的长度
int QueueLength(SqQueue Q)
{
return(Q.rear-Q.front);