队列的基本操作(c语言版)-参考模板
数据结构——用C语言描述(第3版)教学课件第3章 栈和队列
if(S->top==-1) /*栈为空*/
return(FALSE);
else
{*x = S->elem[S->top];
return(TRUE);
}
返回主目录}[注意]:在实现GetTop操作时,也可将参数说明SeqStack *S 改为SeqStack S,也就是将传地址改为传值方式。传 值比传地址容易理解,但传地址比传值更节省时间、 空间。
返回主目录
算法:
void BracketMatch(char *str) {Stack S; int i; char ch; InitStack(&S); For(i=0; str[i]!='\0'; i++) {switch(str[i])
{case '(': case '[': case '{':
3.1.3 栈的应用举例
1. 括号匹配问题
思想:在检验算法中设置一个栈,若读入的是左括号, 则直接入栈,等待相匹配的同类右括号;若读入的是 右括号,且与当前栈顶的左括号同类型,则二者匹配, 将栈顶的左括号出栈,否则属于不合法的情况。另外, 如果输入序列已读尽,而栈中仍有等待匹配的左括号, 或者读入了一个右括号,而栈中已无等待匹配的左括 号,均属不合法的情况。当输入序列和栈同时变为空 时,说明所有括号完全匹配。
return(TRUE);
}
返回主目录
【思考题】
如果将可利用的空闲结点空间组织成链栈来管理,则申 请一个新结点(类似C语言中的malloc函数)相当于链 栈的什么操作?归还一个无用结点(类似C语言中的 free函数)相当于链栈的什么操作?试分别写出从链栈 中申请一个新结点和归还一个空闲结点的算法。
queue的用法和样例
queue的用法和样例队列(Queue)是计算机科学中常用的数据结构,具有先进先出(FIFO)的特性。
队列常用于需要按照顺序处理的场景,例如任务调度、广度优先搜索、缓冲等。
队列的基本操作:1.入队(Enqueue):将元素添加到队列的尾部。
2.出队(Dequeue):从队列的头部移除并返回元素。
3.查看头部元素(Front):查看队列的头部元素,但不移除。
4.判空(isEmpty):检查队列是否为空。
5.获取队列大小(Size):获取队列中元素的个数。
队列的实现方式:1.数组实现:使用数组来存储队列元素,通过两个指针分别记录队列头和尾的位置。
但在动态队列中,可能需要考虑数组大小的调整。
public class ArrayQueue<T>{private static final int DEFAULT_CAPACITY =10;private Object[]array;private int front,rear,size;public ArrayQueue(){array =new Object[DEFAULT_CAPACITY];front =rear =size =0;}public void enqueue(T item){if(size ==array.length){resize();}array[rear++]=item;size++;}public T dequeue(){if(isEmpty()){throw new NoSuchElementException("Queue is empty ");}T item =(T)array[front++];size--;return item;}public T front(){if(isEmpty()){throw new NoSuchElementException("Queue is empty ");}return(T)array[front];}public boolean isEmpty(){return size ==0;}public int size(){return size;}private void resize(){int newSize =array.length*2;array =Arrays.copyOf(array,newSize);}}2.链表实现:使用链表来实现队列,每个节点包含一个元素和指向下一个节点的引用。
结构体类型的队列
结构体类型的队列1. 介绍队列是一种常见的数据结构,它遵循先进先出(FIFO)的原则,即最先进入队列的元素最先被取出。
在编程中,我们经常需要使用队列来处理一系列按顺序排列的数据。
在C语言中,可以使用结构体类型来实现队列。
结构体是一种用户自定义的数据类型,它可以包含多个不同类型的成员变量。
通过定义一个结构体类型,并使用该类型创建变量,我们可以将多个相关联的数据组织在一起。
本文将介绍如何使用结构体类型实现一个简单的队列,并提供相应的代码示例和解释。
2. 队列结构体定义首先,我们需要定义一个结构体来表示队列。
该结构体应该包含两个成员变量:一个用于存储队列元素的数组和两个指针分别指向队头和队尾。
#define MAX_SIZE 100typedef struct {int elements[MAX_SIZE];int front;int rear;} Queue;上述代码中,elements数组用于存储队列中的元素,front指针指向队头元素所在位置,rear指针指向下一个可插入元素的位置。
3. 队列操作函数接下来,我们需要实现一些操作函数来对队列进行操作。
以下是一些常用的队列操作函数:3.1 初始化队列在使用队列之前,我们需要先初始化它。
初始化操作包括将front和rear指针都设置为-1,表示队列为空。
void initQueue(Queue *queue) {queue->front = -1;queue->rear = -1;}3.2 判断队列是否为空我们可以通过判断front和rear指针是否相等来确定队列是否为空。
如果它们相等且不为-1,则表示队列为空。
int isEmpty(Queue *queue) {return (queue->front == queue->rear && queue->front == -1);}3.3 判断队列是否已满当插入元素到达数组的末尾时,我们认为队列已满。
数据结构(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++中队列的用法
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.生产者-消费者问题:队列可以用于解决生产者-消费者问题。
生产者将数据添加到队列中,消费者从队列中取出数据并处理它们。
队列动作七个内容
队列动作七个内容队列动作七个内容队列是计算机科学中非常重要的数据结构,它是一种先进先出(FIFO)的数据结构,具有很多应用。
在实际编程中,我们经常需要对队列进行一些操作,这些操作被称为队列动作。
本文将介绍队列动作的七个内容。
一、入队(Enqueue)入队是指将一个元素添加到队列的末尾。
当一个新元素被添加到队列中时,它会排在所有已有元素的后面,成为新的末尾元素。
二、出队(Dequeue)出队是指从队列中删除第一个元素,并返回该元素的值。
当一个元素被删除后,其后面所有元素都会向前移动一个位置。
三、查看队首(Peek)查看队首是指返回当前位于队列头部的元素值,但不删除该元素。
这个操作可以让我们了解下一个将要被出队的元素是什么。
四、查看是否为空(IsEmpty)查看是否为空是指判断当前的队列是否为空。
如果没有任何元素在其中,则该方法会返回True;否则返回False。
五、查看大小(Size)查看大小是指返回当前在队列中的元素数量。
这个方法可以帮助我们了解当前有多少个任务等待执行。
六、清空(Clear)清空是指将当前所有元素从队列中删除,使其变为空队列。
这个方法可以帮助我们在需要重新开始时清空队列。
七、遍历(Traverse)遍历是指依次访问队列中的所有元素。
这个方法可以帮助我们查看当前所有等待执行的任务。
结语以上是队列动作的七个内容。
在实际编程中,我们经常需要使用这些操作来对队列进行管理和操作。
了解这些操作的含义和用途,可以帮助我们更好地理解和使用队列数据结构,提高程序效率和可读性。
队列的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 队列queue的用法
c 队列queue的用法队列(queue)是一种常用的数据结构,具有“先进先出”(First-In-First-Out,FIFO)的特点。
在队列中,元素的插入和删除操作分别在队列的末尾和前端进行。
队列常用于模拟排队、任务调度和缓存等场景。
在C语言中,我们可以使用数组或链表实现队列的功能。
以下是一种使用数组实现的简单队列的示例:```c#include <stdio.h>#define MAX_SIZE 10//定义队列结构typedef struct {int items[MAX_SIZE];int front;int rear;} Queue;//初始化队列void initQueue(Queue *q) {q->front = -1;q->rear = -1;}//判断队列是否为空int isEmpty(Queue *q) {return (q->front == -1 && q->rear == -1); }//判断队列是否已满int isFull(Queue *q) {return (q->rear == MAX_SIZE - 1);//入队操作void enqueue(Queue *q, int data) { if (isFull(q)) {printf("队列已满,无法入队\n"); return;}if (isEmpty(q)) {q->front = q->rear = 0;} else {q->rear++;}q->items[q->rear] = data;printf("元素%d已入队\n", data);//出队操作void dequeue(Queue *q) {if (isEmpty(q)) {printf("队列为空,无法出队\n"); return;}int data = q->items[q->front]; if (q->front == q->rear) {q->front = q->rear = -1;} else {q->front++;}printf("元素%d已出队\n", data);int main() { Queue q; initQueue(&q); enqueue(&q, 1); enqueue(&q, 2); enqueue(&q, 3); dequeue(&q); dequeue(&q); dequeue(&q); dequeue(&q); return 0;}```在上述代码中,我们定义了一个`Queue`结构体,包含一个固定大小的整型数组`items`用于存储队列元素,以及两个整型变量`front`和`rear`表示队列的前端和末尾。
队列训练下达科目流程
队列训练下达科目流程队列是一种常见的数据结构,它按照先进先出(FIFO)的原则进行操作。
在实际应用中,队列常常用于任务调度、缓冲区管理等场景。
在学习和训练队列的过程中,我们可以通过下达科目流程的方式来加深对队列的理解和应用。
一、概述队列是一种线性数据结构,它可以存储一系列具有相同类型的元素。
队列的特点是先进先出,即先进入队列的元素先出队列。
在队列中,新元素都被添加到队列的末尾,而从队列中删除元素的操作则是从队列的头部进行。
二、队列的基本操作1. 入队列(enqueue):将元素添加到队列的末尾。
2. 出队列(dequeue):从队列的头部删除元素,并返回删除的元素。
3. 获取队头元素(front):返回队列的头部元素,但不删除它。
4. 判断队列是否为空(isEmpty):判断队列是否没有任何元素。
三、下达科目流程下达科目流程是一种典型的使用队列进行任务调度的应用场景。
假设有一所学校需要安排学生参加各种科目的考试,下面是一个简单的下达科目流程示例:1. 初始化队列和科目列表:创建一个空队列和包含所有科目的科目列表。
2. 遍历科目列表:- 将每个科目添加到队列中,即入队列操作。
3. 初始化考试顺序列表:创建一个空的考试顺序列表。
4. 当队列不为空时,执行以下步骤:- 从队列中取出队头元素,即出队列操作。
- 将取出的科目添加到考试顺序列表中,即入队列操作。
5. 完成考试顺序列表的构建后,输出考试顺序。
通过上述下达科目流程,我们可以实现对队列的训练和理解。
下面是一个具体的示例,以便更好地理解整个流程:假设有以下科目列表:语文、数学、英语、物理、化学。
根据上述下达科目流程,我们可以按照以下步骤进行操作:1. 初始化队列和科目列表:队列为空,科目列表为[语文、数学、英语、物理、化学]。
2. 遍历科目列表:- 将语文入队列:队列为[语文]。
- 将数学入队列:队列为[语文、数学]。
- 将英语入队列:队列为[语文、数学、英语]。
数据结构-使用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)a,b,c,d C)b,c,d,a
B)c,d,a,b D)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;
队列的常见操作
数据结构面试之四——队列的常见操作题注:《面试宝典》有相关习题,但思路相对不清晰,排版有错误,作者对此参考相关书籍和自己观点进行了重写,供大家参考。
四、队列的基本操作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语言实现)生活中有很多队列的影子,比如打饭排队,买火车票排队问题等,可以说与时间相关的问题,一般都会涉及到队列问题;从生活中,可以抽象出队列的概念,队列就是一个能够实现“先进先出”的存储结构。
队列分为链式队列和静态队列;静态队列一般用数组来实现,但此时的队列必须是循环队列,否则会造成巨大的内存浪费;链式队列是用链表来实现队列的。
这里讲的是循环队列,首先我们必须明白下面几个问题一、循环队列的基础知识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语言版) 第3章 栈和队列
3.1.1 栈的概念
假设有一个栈S=(a1,a2,…,an),栈 中元素按a1,a2,…,an的次序进栈后, 进栈的第一个元素a1为栈底元素,出栈的第 一个元素an为栈顶元素,也就是出栈的操作 是按后进先出的原则进行的,其结构如图31所示。
图3-1栈结构示意图
返回到本节目录
3.1.2栈的基本操作
3.1.3顺序栈
由于栈是操作受限制的线性表,因此与线性表类似,栈也 有两种存储结构,即顺序存储结构和链式存储结构。 1. 顺序栈的定义 栈的顺序存储结构称为顺序栈。类似于顺序表的类型定义,顺 序栈是用一个预设的足够长度的一维数组和一个记录栈顶元素 位置的变量来实现。顺序栈中栈顶指针与栈中数据元素的关1.3顺序栈
3. 顺序栈的基本操作实现
(3)进栈操作 进栈操作的过程如图3-3所示。先判断栈S如图3-3(a) 是否为满,若不满再将记录栈顶的下标变量top加1如 图3-3(b),最后将进栈元素放进栈顶位置上如图33(c)所示,算法描述见算法3.3。
图3-3 进栈操作过程图
返回到本节目录
栈除了在栈顶进行进栈与出栈外,还有初始化、判空 等操作,常用的基本操作有: (1)初始化栈InitStack(S)。其作用是构造一个空 栈 S。 (2)判断栈空EmptyStack(S)。其作用是判断是 否是空栈,若栈S为空,则返回1;否则返回0。 (3)进栈Push(S,x)。其作用是当栈不为满时,将 数据元素x插入栈S中,使其为栈S的栈顶元素。 (4)出栈Pop(S,x)。其作用是当栈S不为空时,将 栈顶元素赋给x,并从栈S中删除当前栈顶元素。 (5)取栈顶元素GetTop(S,x)。其作用是当栈S不 为空时,将栈顶元素赋给x并返回,操作结果只是 读取栈顶元素,栈S不发生变化。 返回到本节目录
队列实现杨辉三角形(数据结构)(c语言)
用队列实现杨辉三角形在数据结构中,队列是一种非常常用的数据结构,其基本操作包括入队、出队、队列大小等。
利用队列的先进先出的特性,我们不仅可以解决简单的数据存储问题,还可以实现许多更加复杂的算法。
其中,一道有趣的题目就是用队列实现杨辉三角形。
首先,我们需要了解杨辉三角形的概念和特点。
杨辉三角形是一个数列,其每一行由从左到右逐渐增加的数字组成,而且每一行的首尾都是1。
中间的数字由上一行相邻的两个数字相加得到。
以下是杨辉三角形的前几行:11 11 2 11 3 3 11 4 6 4 1在实现杨辉三角形的过程中,我们可以利用队列的特性来存储每个数字。
具体来说,我们可以每次将一行的数字存储到一个队列中,并且在生成下一行数字时,根据队列中上一行的数字求出新的一行数字。
具体实现过程如下:1. 定义一个队列,并将1入队。
2. 对于每一行,我们可以先将1入队,然后根据上一行计算新的数字序列,将其逐一入队。
3. 每次生成新行数字序列时,都需要更新队列中的数据,即出队首元素,插入新的末尾元素。
4. 重复2-3步,直到生成的行数达到指定数目。
通过以上过程,我们就可以用队列实现杨辉三角形了。
实际上,在这个过程中,我们让每一行的数字序列都成为了队列中的元素,而依次入队出队的过程,也相当于在按照规律生成每一行数字序列。
这种算法虽然看似复杂,但实际上非常巧妙,也能够充分发挥队列数据结构的优势。
综上所述,用队列实现杨辉三角形是一道很有意思的题目,不仅能够锻炼我们的编程能力,还可以让我们更深入地理解队列数据结构和算法的本质。
如果你正在学习数据结构和算法,不妨尝试一下这道题目,相信它会给你带来更多的收获。
队列的基本操作操作 命令选择型的测试程序
工作(学习)日志日期时间: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");}心得:。
消息队列 程序 c语言
消息队列程序 c语言
消息队列是一种在程序之间进行通信和数据交换的机制。
在C 语言中,可以通过系统提供的消息队列相关函数来实现消息队列的操作。
消息队列通常用于进程间通信,允许不同的进程在没有共享内存的情况下进行数据交换。
在C语言中,可以使用系统提供的消息队列函数来创建、发送和接收消息。
常用的函数包括:
1. `msgget`,用于创建一个新的消息队列或获取一个已存在的消息队列的标识符。
2. `msgsnd`,用于向消息队列发送消息。
3. `msgrcv`,用于从消息队列接收消息。
4. `msgctl`,用于控制消息队列,如删除消息队列等操作。
在使用消息队列时,需要注意消息的格式和大小,以及消息队列的权限和标识符等信息。
此外,还需要处理消息队列可能出现的
阻塞和超时等情况,确保程序的稳定性和可靠性。
除了基本的消息队列操作外,还可以结合多线程或者多进程的编程技术,实现更复杂的消息队列应用,比如实现生产者-消费者模型、事件驱动模型等。
总之,在C语言中使用消息队列需要充分了解消息队列的原理和相关函数的用法,同时结合具体的应用场景进行设计和开发,以实现程序之间的高效通信和数据交换。
并发队列c语言实现
并发队列c语言实现在多线程编程中,由于多个线程同时访问共享数据结构可能导致数据的不一致性,因此需要使用互斥锁或信号量等机制来保护共享数据的操作。
而并发队列是一种特殊的数据结构,它可以同时支持多个线程对队列进行操作,而不需要显式地使用互斥锁等机制。
在C语言中,可以使用一个线程安全的队列结构来实现并发队列。
下面是一个简单的示例代码:```c#include <stdio.h>#include <stdlib.h>#include <pthread.h>#define QUEUE_SIZE 100typedef struct {int data[QUEUE_SIZE];int front;int rear;pthread_mutex_t mutex;pthread_cond_t not_empty;pthread_cond_t not_full;} ConcurrentQueue;void init_queue(ConcurrentQueue* queue) {queue->front = 0;queue->rear = 0;pthread_mutex_init(&(queue->mutex), NULL);pthread_cond_init(&(queue->not_empty), NULL);pthread_cond_init(&(queue->not_full), NULL);}void enqueue(ConcurrentQueue* queue, int value) {pthread_mutex_lock(&(queue->mutex));while ((queue->rear + 1) % QUEUE_SIZE == queue->front) {pthread_cond_wait(&(queue->not_full), &(queue->mutex));}queue->data[queue->rear] = value;queue->rear = (queue->rear + 1) % QUEUE_SIZE;pthread_cond_signal(&(queue->not_empty));pthread_mutex_unlock(&(queue->mutex));}int dequeue(ConcurrentQueue* queue) {pthread_mutex_lock(&(queue->mutex));while (queue->front == queue->rear) {pthread_cond_wait(&(queue->not_empty), &(queue->mutex));}int value = queue->data[queue->front];queue->front = (queue->front + 1) % QUEUE_SIZE;pthread_cond_signal(&(queue->not_full));pthread_mutex_unlock(&(queue->mutex));return value;}int main() {ConcurrentQueue queue;init_queue(&queue);// 创建多个线程进行入队和出队操作pthread_t thread1, thread2;pthread_create(&thread1, NULL, (void*)enqueue, &queue); pthread_create(&thread2, NULL, (void*)dequeue, &queue); // 主线程等待子线程结束pthread_join(thread1, NULL);pthread_join(thread2, NULL);return 0;}```在上述代码中,ConcurrentQueue结构体表示并发队列,其中包含了一个固定大小的数组data用来存储队列的元素,以及front和rear分别表示队列的头部和尾部。
软件技术--队列
lq[rear]=x; } }
(3)出队列
出队列成功,返回x;否则给出相应信息。
datatype delloopque(datatype lq[]) {datatype x; if (front= =rear) {printf("队列为空!下溢!\n"); return(0); } else {front=(front+1)%N;
(4)取队头元素 取队头数据使用,不删除该数据元 素;
(5)队列空判断 判断队列是否为空,是出队列和 取队头元素时常用的操作;
(6)队列满判断 判断队列是否已满,是进队时首 先进行的操作。
※顺序队列
队列的顺序存储是指用一组连续的存储单元依次存放队列中的元素。在 C语言中用一维数组来存放队列中的元素。因为队列的队头和队尾的位置是 变化的,所以还需附设两个指针front和rear,front指针指向队列头元素的 位置,rear指针指向队列尾元素的位置。约定当队列为空时,令 front=rear=-1。每当插入新的队尾元素时,尾指针rear增加1;每当删除队 头元素时,头指针front增加1。
front= =( rear+1)%N; 成立时,认定队列为满。当判断队列为空时,条件是:front= = rear;
※循环队列的基本算法
这里以第二种方法区别循环队列的空、满状态。 循环队列的类型定义: #define N 100 datatype lq[N];
int front,rear;
(1)构造空队列
如下图(a)所示循环队列中,队列头元素是A,尾元素是C。当元素A、B、 C从图4-15(a)所示的队列中删除后,则队列变成空的状态,如图(b)所示。 反之,在图(a)的队列中,若元素D、E、F相继插入,则队列空间被占满,如图 (c)所示。不管队列为空还是为满,均出现front= =rear的情况。因此仅凭 front= = rear不能判定队列是空还是满。
C语言数据队列
C语言数据队列数据队列是一种常用的数据结构,用于实现数据的先进先出(FIFO)的存储和操作。
在C语言中,可以通过使用数组或者链表来实现数据队列。
本文将介绍如何在C语言中使用数组实现队列,并提供相应的实例代码。
一、队列的定义与基本操作队列是一种线性数据结构,具有两个基本操作:入队和出队。
入队(enqueue)将一个元素添加到队列的末尾,而出队(dequeue)将队列的第一个元素从队列中移除。
另外,队列还有两个重要的概念:队头(Front)和队尾(Rear),分别指向队列中的第一个元素和最后一个元素。
在使用数组实现队列时,需要定义一个固定大小的数组,同时维护队头和队尾的索引。
具体的操作如下:1. 创建队列:定义一个固定大小的数组和两个指针 front 和 rear,分别初始化为 -1。
2. 判断队列是否为空:如果 front == -1,则表示队列为空。
3. 入队操作:将元素添加到队列的末尾,即将 rear 指针后移一位,并将元素存储到 rear 所指的位置。
4. 出队操作:将队列的第一个元素移除,即将front 指针后移一位。
5. 判断队列是否已满:如果 rear 指针已经达到数组的最大索引,则表示队列已满。
6. 获取队头元素:返回队头指针 front 所指的元素。
7. 获取队列长度:通过rear 和front 的差值加一来获取队列的长度。
下面是使用数组实现队列的C语言代码:```c#include <stdio.h>#define MAX_SIZE 100int queue[MAX_SIZE];int front = -1;int rear = -1;int isEmpty() {if (front == -1)return 1;return 0;}int isFull() {if (rear == MAX_SIZE - 1)return 1;return 0;}void enqueue(int data) {if (isFull()) {printf("队列已满,无法入队。
队列基本操作实验报告
队列基本操作实验报告一、实验目的本次实验的主要目的是通过编写队列的基本操作,掌握队列数据结构的基本原理及其应用。
二、实验内容1. 队列的定义和基本操作队列是一种先进先出(FIFO)的线性数据结构,它只允许在队尾插入元素,在队头删除元素。
队列的基本操作包括:入队(enqueue)、出队(dequeue)、获取队头元素(getFront)、获取队列长度(getSize)等。
2. 队列的顺序存储结构顺序存储结构是指用数组来存储队列中的元素,其中需要维护两个指针:front指向队头元素,rear指向下一个待插入位置。
当rear等于数组长度时,需要进行循环,即将rear置为0。
3. 队列的链式存储结构链式存储结构是指用链表来存储队列中的元素,其中每个节点包含一个数据域和一个指针域。
head指向链表头节点,tail指向链表尾节点。
4. 实验流程(1) 编写顺序存储结构下的队列基本操作函数。
(2) 编写链式存储结构下的队列基本操作函数。
(3) 分别测试两种存储方式下各个函数是否正确实现。
三、实验步骤1. 顺序存储结构下的队列基本操作函数(1) 定义队列结构体和初始化函数。
typedef struct {int *data;int front, rear;int maxSize;} SeqQueue;SeqQueue* initSeqQueue(int maxSize) {SeqQueue *q = (SeqQueue*)malloc(sizeof(SeqQueue));q->data = (int*)malloc(sizeof(int) * maxSize);q->front = q->rear = 0;q->maxSize = maxSize;return q;}(2) 实现入队操作。
bool enqueue(SeqQueue *q, int x) {if ((q->rear + 1) % q->maxSize == q->front) return false; // 队满q->data[q->rear] = x;q->rear = (q->rear + 1) % q->maxSize; // 循环return true;}(3) 实现出队操作。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
/*若链队为空则停止运行*/
if(Q->front == NULL){
printf("队列为空,无法删除!");
exit(1);
}
return Q->fห้องสมุดไป่ตู้ont->data;
/*返回队首元素*/
}
/*第五个操作判断队列是否为空*/
int emptyQueue(struct LinkQueue *Q)
struct QueuePtr *rear;
};
void initQueue(struct LinkQueue *Q)
/*第一个操作构造一个空队列q*/
{
Q->front = Q->rear = NULL;
/*把队首和队尾指针置空*/
return;
}
void push(struct LinkQueue *Q, elemType x)
/*队首指针赋给p */
/*依次删除队列中的每一个结点,最后使队首指针为空*/
while(p != NULL){
Q->front = Q->front->next;
free(p);
p = Q->front;
} /*循环结束后队首指针已经为空*/
Q->rear = NULL;
printf("\n队列已经清空\n");
printf("2--操作gettop返回队列顶元素e\n");
printf("3--操作enQueue插入元素e到队里尾部\n");
printf("4--操作pop删除Q队列的首元素\n");
printf("5--操作clearQueue将Q清为空队列\n");
printf("6--操作emptyQueue判断Q是否为空队列,是返回0,否返回1;\n");
printf("\n请输入一个要插入队列的元素:");
scanf("%d",&b);
push(&Q,b);break;
case 4:
c=pop(&Q);
printf("\n删除的元素是%d\n",c);
break;
case 5:
clearQueue(&Q);
break;
case 6:
d=emptyQueue(&Q);
#include<stdio.h>
#include<stdlib.h>
typedef int elemType;
struct QueuePtr{
elemType data;
struct QueuePtr *next;
};
struct LinkQueue{
struct QueuePtr *front;
{
/*判断队首或队尾任一个指针是否为空即可*/
if(Q->front == NULL){
printf("asd");
return 0;
}
else{
printf("dfg");
return 1;
}
}
/*第六个操作清空队列*/
void clearQueue(struct LinkQueue *Q)
{
struct QueuePtr *p = Q->front;
return;
}
int main()
{
struct LinkQueue Q;
int i;
int a,b,c,d;
a=b=c=d=0;
// initQueue(&q);
while(1)
{
printf("\n每种方法都对应一个编号,输入编号进行相应的操作。\n");
printf("1--操作initQueue构造一个队列Q\n");
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;
/*第二个操作插入元素e为q的新的队尾元素*/
{
/*得到一个由newP指针所指向的新结点*/
struct QueuePtr *newP;
newP = (struct QueuePtr*)malloc(sizeof(struct QueuePtr));
if(newP == NULL){
printf("内存空间分配失败!");
printf("\n队列是%d 0是空,1是非空\n",d);
break;
case 7:
goto quit;
default:printf("请输入1-6之间的数字。\n");
}
}
quit:
system("pause");
}
---精心整理,希望对您有所帮助
printf("7--退出程序\n");
printf("请选择一个基本操作:");
scanf("%d",&a);
switch(a)
{
case 1:initQueue(&Q);break;
case 2:
c=0;
c=gettop(&Q);
printf("\n队列头元素是%d\n",c);
break;
case 3:
/*使队首指针指向下一个结点*/
/*若删除后链队为空,则需同时使队尾指针为空*/
if(Q->front == NULL){
Q->rear = NULL;
}
free(p); /*回收原队首结点*/
return temp; /*返回被删除的队首元素值*/
}
/*第四个操作返回队列头元素*/
elemType gettop(struct LinkQueue *Q)