队列的入队出队初始化操作

队列的入队出队初始化操作
队列的入队出队初始化操作

实践考核题第一题设计报告书

学生姓名 XXX 学生学号099XXX

所在地区XXX 提交日期(年/月)2014/6

实践题目利用队列的结构解决实际问题

需求分析

置空函数:根据函数的形参,即传递进来的队列指针,调用它的首指针和尾指针让两个指针相等,就把队列中的元素全部清空。

入队函数:首先判断该队列是否已满,如果队列已满,就退出操作。否则,

执行入队操作的语句,由于是循环队列所以在移动尾指针时,要把尾指针的位置取余运算(queue.rear=(queue.rear+1)%maxsize;),然后把数据元素赋给尾指针(queue,data[queue.rear]=x;)。

出队函数:当有数据元素要出队时,首先判断该队列是否为空,如果为空

时,元素出队列失败。否则,当队列不为空时,执行出队操作(queue.front=(queue.front+1)%maxsize;)返回数值1,说明出队成功。

判空函数:该函数是用来判断队列是否为空的,是被别的函数调用作为判

断条件用,若果为空的话就返回数值0,标志不能继续执行下面的语句。判断为空的条件是:queue.rear==queue.front;如果为空返回值为1,否则返回值为0。

概要设计

1)置空 setnull ( queue ) 将队列 queue 置成空队列

调用setnull(queue)函数把队列queue的顶端指针和低端指针指向同一块地址,这样就把队列置空。当队列中的数据元素不用或者必须要清楚的时候,就必须调用该函数把队列中的数据清空才能在插入新的数据供用户操作使用。

2)入队 enqueue ( queue , x ) 将元素 x 插入队列 queue 的尾

调用函数enqueue(queue,x),通过移动首指针找到要入队的数据,直到把队列的空间占满。有数据要进入队列时,调用该函数把数据元素x插入到队列中,先判断队列是否已满让后才能把数据元素插入到队尾。

3)出队 dequeue ( queue ) 删除队列 queue 的队头元素,函数返

回被删除元素的值

通过移动首指针把队首的指针往下移动一个地址,这样就把一个元素数据出队了。当要出队时,队列是从头指针开始一系列操作。先判断该队列是否为空队列,如果不是的话,在进行出队操作把头指针往上移一个地址,这样就把数据出队了。

4)判队列是否为空 EmptyQueue( queue ) 若队列que为空,函数返

回 0 ,否则返回 1

判断队列的为空的条件是(queue.rear==queue.front)如果为空返回数值1,否则返回0。当出队操作时,需要判断队列是否为空,调用该函数。

详细设计

#include//头文件

//带头结点的循环链表表示队列

#define maxsize 10

typedef struct

{

int data[maxsize];

int front;

int rear;

}queue;

//初始化队列

queue setnull(queue CQ)

{

CQ.front=0;

CQ.rear=0;

return CQ ;

}

//判断队列是否为空

int EmptyQueue(queue CQ)

{

if(CQ.rear==CQ.front)

//队列为空,返回1

return 1;

else

return 0;

}

//入队列

queue enqueue(queue CQ,int x)

{

if((CQ.rear+1)%maxsize==CQ.front) {//队列空间已满

printf("queue full");

}

else

{

//将尾指针后移

CQ.rear=(CQ.rear+1)%maxsize;

//并显示尾指针位置

printf("see what CQ.rear is :%d\n",CQ.rear);

//存入数据

CQ.data[CQ.rear]=x;

}

return CQ;//返回修改后的队列

}

//出队列

queue dequeue(queue CQ)

{//判断队列是否为空

if(EmptyQueue(CQ))

{

printf("space queue\n");

}

else

{

//记录将要清除的数据

int x=CQ.data[(CQ.front+1)%maxsize];

//头指针后移

CQ.front=(CQ.front+1)%maxsize;

//输出清除掉的数据

printf("the deleted data %d\n", x);

}

return CQ;

}

//主函数

int main()

{

queue que;

int x;

//调用置空函数

que=setnull(que);

printf("please put the data (put 999 end):\n");

for(int i=0;i<9;i++)

{//循环调用入队函数

scanf("%d",&x);

//限定结束符号

if(x==999)

{

printf("put data end.\n");

break;

实验二 栈与队列操作实验题目

实验二栈与队列操作 实验目的: (1)理解栈与队列的结构特征和运算特征,以便在实际问题背景下灵活运用。 (2)了解复杂问题的递归算法设计。 本次实验中,下列实验项目选做一。 1、顺序栈的基本操作 [问题描述] 设计算法,实现顺序栈的各种基本操作 [基本要求] (1)初始化栈s。 (2)从键盘输入10个字符以$结束,建立顺序栈。 (3)从键盘输入1个元素,执行入栈操作。 (4)将栈顶元素出栈。 (5)判断栈是否为空。 (6)输出从栈顶到栈底元素。 要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。 2、链栈的基本操作 [问题描述] 设计算法,实现链栈的各种基本操作 [基本要求] (1)初始化栈s。 (2)从键盘输入10个字符以$结束,建立带头结点的链栈。 (3)从键盘输入1个元素,执行入栈操作。 (4)完成出栈操作。 (5)判断栈是否为空。 (6)输出从栈顶到栈底元素。 (7)输出链栈的长度。 要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。 3、循环队列的基本操作 [问题描述] 设计算法,实现循环顺序队列的建立、入队、出队等操作。 [基本要求] (1)从键盘输入10个字符以$结束,建立循环队列,并显示结果。 (2)从键盘输入1个元素,执行入队操作,并显示结果。 (3)将队头元素出队,并显示结果。 (4)要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。

4、只用尾指针表示的循环链表队列的综合操作 [问题描述] 假设以带头结点的的循环链表表示队列,并且只设一个指针指向队尾元素的结点(注意不设头指针),试编写队列初始化、入队、出队函数。 [基本要求及提示] (1)首先定义链表结点类型。 (2)编写带头结点的循环链表的初始化函数,只用尾指针表示。 (3)编写入队函数、出队函数。 (4)在主函数中编写菜单(1.初始化;2.入队;3.出队;4.退出),调用上述功能函数。 5、用标志域表示队空队满状态的循环队列的综合操作 [问题描述] 要求循环队列不损失一个空间全部都得到利用,设置一个标志域tag,以0和1来区分当队头与队尾指针相同时队列状态的空和满,试编写与此结构相对应的入队和出队操作。 [基本要求及提示] (1)教材中为区分当队头与队尾指针相同时队列状态的空和满,以牺牲一个空间的代价来实现的,空:Q->front==Q->rear,满:(Q->rear+1)%MAXSIZE==Q->front。 (2)本题不损失一个空间全部都得到利用,为此如下定义循环队列类型: Typedef struct { QueueElementType element[MAXSIZE]; int front; int rear; int tag; }SeqQueue; 此时,循环队列空和满的条件分别为: Q->front==Q->rear&&tag==0 和 Q->front==Q->rear&&tag==1 (3)编写入队函数、出队函数。 (4)在主函数中编写菜单(1.入队;2.出队;3.退出),调用上述功能函数。 6、利用辅助数组进行栈的逆置 [问题描述] 利用辅助栈将栈中的元素逆置。 [基本要求及提示] 在主函数中编写菜单(1.入栈;2.出栈;3.逆置;4.退出)调试运行程序。 7、利用辅助栈进行队列的逆置 [问题描述] 利用辅助栈进行队列元素逆置。 [基本要求及提示] 在主函数中编写菜单(1.入队;2.出队;3.逆置;4.退出)调试运行程序。 8、Hanoi塔问题

3 实现队列的入队操作

实现队列的入队操作 函数原型: void insertNode(struct Queue* queue , ElementType value){ } 其中参数queue 是带插入元素的队列指针,后面的value 当然就是需要插入的值了。 下面写具体的逻辑: int isEmpty(struct Queue* queue){ // 判断队列是否为空,如果为空则返回 1 // 不为空则返回 0 return queue->count == 0; } void insertNode(struct Queue* queue , ElementType value){ // 创建一个新的节点 node ,并让这个节点的值等于value , next指针指向NULL struct Node* node = newNode(value , NULL); // 如果队列为空 if(isEmpty(queue)){ // 让 front 指针指向新的节点 node queue->front = node; //让 tail 指针指向新的节点 node queue->tail = node; /* * 大家可以回想以想在图示的过程中,当队列 * 为空的时候,我是没画 front 指针和 tail指针的 * 这个时候让 font 和 tail 都指向空就好了,也就是初始化 * 的时候让 font 和 tail 都指向了 NULL(空) * NULL 其实是一个宏,它的值是 0(整型 0) * 当队列中添加了第一个元素的时候我才画出来 * font 指针和 tail 指针,并且让 font 和 tail * 都指向了第一个节点,就想现在,如果队列在添加节点的时候为空 * 则执行上面的操作 * */ }else{ //如果队列不为空 /* * 大家再看一下图示过程中,当队列中有一个节点的时候,

第3章-栈与队列习题参考答案

习题三参考答案 备注: 红色字体标明的是与书本内容有改动的内容。 一、选择题 1.在栈中存取数据的原则是( B )。 A.先进先出 B. 先进后出 C. 后进后出 D. 没有限制 2.若将整数1、2、3、4依次进栈,则不可能得到的出栈序列是( D )。 A.1234 B. 1324 C. 4321 D. 1423 3.在链栈中,进行出栈操作时(B )。 A.需要判断栈是否满 B. 需要判断栈是否为空 C. 需要判断栈元素的类型 D. 无需对栈作任何差别 4.在顺序栈中,若栈顶指针top指向栈顶元素的下一个存储单元,且顺序栈的最大容量是maxSize,则顺序栈的判空条件是( A )。 A.top==0 B.top==-1 C. top==maxSize D.top==maxSize-1 5.在顺序栈中,若栈顶指针top指向栈顶元素的下一个存储单元,且顺序栈的最大容量是maxSize。则顺序栈的判满的条件是( C )。 A.top==0 B.top==-1 C. top==maxSize D.top==maxSize-1 6.在队列中存取数据元素的原则是( A )。 A.先进先出 B. 先进后出 C. 后进后出 D. 没有限制 7.在循环顺序队列中,假设以少用一个存储单元的方法来区分队列判满和判空的条件,front和rear分别为队首和队尾指针,它们分别指向队首元素和队尾元素的下一个存储单元,队列的最大存储容量为maxSize,则队列的判空条件是(A )。 A.front==rear B. front!=rear C. front==rear+1 D. front==(rear+1)% maxSize 8.在循环顺序队列中,假设以少用一个存储单元的方法来区分队列判满和判空的条件,front和rear分别为队首和队尾指针,它们分别指向队首元素和队尾元素的下一个存储单元,队列的最大存储容量为maxSize,则队列的判满条件是(D )。 A.front==rear B. front!=rear C. front==rear+1 D. front==(rear+1)% maxSize 9.在循环顺序队列中,假设以少用一个存储单元的方法来区分队列判满和判空的条件,front和rear分别为队首 和队尾指针,它们分别指向队首元素和队尾元素的下一个存储单元,队列的最大存储容量为maxSize,则队列的长度是(C )。 A.rear-front B. rear-front+1 C. (rear-front+maxSize)%maxSize D. (rear-front+1)%maxSize 10.设长度为n的链队列采用单循环链表加以表示,若只设一个头指针指向队首元素,则入队操作的时间复杂度 为( B )。 A.O(1) B.O(n) C.O(log2n) D.O(n2) 二、填空题 1.栈是一种操作受限的特殊线性表,其特殊性体现在其插入和删除操作都限制在表尾进行。允许插入和删除 操作的一端称为栈顶,而另一端称为栈底。栈具有后进先出的特点。 2.栈也有两种存储结构,一种是顺序存储,另一种是链式存储;以这两种存储结构存储的栈分别称为顺序 栈和链栈。 3.在顺序栈中,假设栈顶指针top是指向栈顶元素的下一个存储单元,则顺序栈判空的条件是 top==0 ; 栈顶

顺序队的基本操作

上机实验报告 学院:计算机与信息技术学院 专业:计算机科学与技术(师范)课程名称:数据结构 实验题目:顺序队的基本操作 班级序号:师范1班 学号: 2731 学生姓名:邓雪 指导教师:杨红颖 完成时间: 2015年12月25号

一、实验目的: 1.熟悉掌握队的定义、结构及性质;? 2. 熟练掌握循环队列的操作及应用,掌握循环队列的入队和出队等基本操作。? 3. 加深对队列结构的理解,逐步培养解决实际问题的编程能力 二、实验环境: Windows Microsoft Visual c++ 三、实验内容及要求: 掌握队列的概念及性质,并建立顺序队,实现如下功能: 1.建立一个顺序队 2.输出队 3.求队长 4.判队空 5.取队头 6.入队 7.出队 8. 清空栈 四、概要设计: 1、通过循环,由键盘输入一串数据。创建并初始化一个顺序队。 2、编写实现相关功能函数,完成子函数模块如下。 3、调用子函数,实现菜单调用功能,完成顺序表的相关操作。

#include <> #include <> #define maxsize 1024 typedef int datatype; //定义结构体 typedef struct { datatype data[maxsize]; int front,rear; }sequeue; sequeue *sq; //建立顺序队 sequeue *SET() { sequeue *sq; datatype x; sq=(sequeue *)malloc(sizeof(sequeue)); sq->front=maxsize-1; sq->rear=maxsize-1; printf("请输入要存入的结点值(以0结尾)\n"); scanf("%d",&x); while(x!=0) { sq->rear=(sq->rear+1)%maxsize; sq->data[sq->rear]=x; scanf("%d",&x); } printf("顺序队输入成功\n\n"); return sq; }

循环队列的入队和出队

循环队列的入队和出队 程序如下: #include #include #include #include #define Max 20 typedef struct { int data[Max+1]; int front,rear; }SeqQueue; void SetNull(SeqQueue *q) { q->front=q->rear=0; } int Empty(SeqQueue *q) { if(q->rear ==q->front ) return 1; else return 0; } int GetFront(SeqQueue *q) { if(Empty(q)) { printf("队空"); exit(1); } else return(q->data[(q->front +1)%Max]); } int EnQueue(SeqQueue *q,int x) { if(q->front==(q->rear+1)%Max) { printf("溢出!\n"); exit(1); } else { q->rear=(q->rear+1)%Max;

q->data[q->rear]=x; return 1; } } int DeQueue(SeqQueue *q) { if(Empty(q)) { printf("队列为空!\n"); exit(1); } else { q->front =(q->front +1)%Max; return(q->data [q->front ]); } } void main() { int x; int n,i; SeqQueue *q; q=(SeqQueue*)malloc(sizeof(SeqQueue)); SetNull(q); printf("请输入入队元素的个数:"); scanf("%d",&n); printf("请输入入队元素:"); for(i=0;i

数据结构第3章 栈与队列习题

第3章栈与队列 一、单项选择题 1.元素A、B、C、D依次进顺序栈后,栈顶元素是,栈底元素是。 A.A B.B C.C D.D 2.经过以下栈运算后,x的值是。 InitStack(s);Push(s,a);Push(s,b);Pop(s,x);GetTop(s,x); A.a B.b C.1 D.0 3.已知一个栈的进栈序列是ABC,出栈序列为CBA,经过的栈操作是。 A.push,pop,push,pop,push,pop B.push,push,push,pop,pop,pop C.push,push,pop,pop,push,pop D.push,pop,push,push,pop,pop 4.设一个栈的输入序列为A、B、C、D,则借助一个栈所得到的序列是。 A.A,B,C,D B.D,C,B,A C.A,C,D,B D.D,A,B,C 5.一个栈的进栈序列是a,b,c,d,e,则栈的不可能的输出序列是。 A.edcba B.decba C.dceab D.abcde 6.已知一个栈的进栈序列是1,2,3,……,n,其输出序列的第一个元素是i,则第j个出栈元素是。 A.i B.n-i C.j-i+1 D.不确定 7.已知一个栈的进栈序列是1,2,3,……,n,其输出序列是p1,p2,…,Pn,若p1=n,则pi的值。 A.i B.n-i C.n-i+1 D.不确定 8.设n个元素进栈序列是1,2,3,……,n,其输出序列是p1,p2,…,p n,若p1=3,则p2的值。 A.一定是2 B.一定是1

C.不可能是1 D.以上都不对 9.设n个元素进栈序列是p1,p2,…,p n,其输出序列是1,2,3,……,n,若p3=1,则p1的值。 A.可能是2 B.一定是1 C.不可能是2 D.不可能是3 10.设n个元素进栈序列是p1,p2,…,p n,其输出序列是1,2,3,……,n,若p3=3,则p1的值。 A.可能是2 B.一定是2 C.不可能是1 D.一定是1 11.设n个元素进栈序列是p1,p2,…,p n,其输出序列是1,2,3,……,n,若p n=1,则p i(1≤i≤n-1)的值。 A.n-i+1 B.n-i C.i D.有多种可能 12.判定一个顺序栈S为空的条件为。 A.S.top= =S.base B.S.top!= S.base C.S.top!= S.base+S.stacksize D.S.top= = S.base+S.stacksize 13.判定一个顺序栈S为栈满的条件是。 A.S.top-S.base= =S.stacksize B.S.top= = S.base C.S.top-S.base!=S.stacksize D.S.top!= S.base 14.链栈与顺序栈相比有一个明显的优点,即。 A.插入操作方便B.通常不会出现栈满的情况 C.不会出现栈空的情况D.删除操作更加方便 15.最不适合用作链栈的链表是。 A.只有表头指针没有表尾指针的循环双链表 B.只有表尾指针没有表头指针的循环双链表 C.只有表尾指针没有表头指针的循环单链表 D.只有表头指针没有表尾指针的循环单链表 16.如果以链表作为栈的存储结构,则退链栈操作时。 A.必须判别链栈是否满B.判别链栈元素的类型 C.必须判别链栈是否空D.对链栈不作任何判别

《数据结构》习题集:第3章 栈和队列

第3章栈和队列 一、选择题 1.栈结构通常采用的两种存储结构是(A )。 A、顺序存储结构和链表存储结构 B、散列和索引方式 C、链表存储结构和数组 D、线性链表结构和非线性存储结构 2.设栈ST 用顺序存储结构表示,则栈ST 为空的条件是( B ) A、ST.top-ST.base<>0 B、ST.top-ST.base==0 C、ST.top-ST.base<>n D、ST.top-ST.base==n 3.向一个栈顶指针为HS 的链栈中插入一个s 结点时,则执行( C ) A、HS->next=s; B、s->next=HS->next;HS->next=s; C、s->next=HS;HS=s; D、s->next=HS;HS=HS->next; 4.从一个栈顶指针为HS 的链栈中删除一个结点,用x 保存被删除结点的值,则执行( C) A 、x=HS;HS=HS->next; B 、HS=HS->next;x=HS->data; C 、x=HS->data;HS=HS->next; D 、s->next=Hs;Hs=HS->next; 5.表达式a*(b+c)-d 的后缀表达式为( B ) A、abcdd+- B、abc+*d- C、abc*+d- D、-+*abcd 6.中缀表达式A-(B+C/D)*E 的后缀形式是( D ) A、AB-C+D/E* B、ABC+D/E* C、ABCD/E*+- D、ABCD/+E*- 7.一个队列的入列序列是1,2,3,4,则队列的输出序列是( B ) A、4,3,2,1 B、1,2,3,4 C、1,4,3,2 D、3,2,4,1 8.循环队列SQ 采用数组空间SQ.base[0,n-1]存放其元素值,已知其头尾指针分别是front 和rear,则判定此循环队 列为空的条件是() A、Q.rear-Q.front==n B、Q.rear-Q.front-1==n C、Q.front==Q.rear D、Q.front==Q.rear+1 9.循环队列SQ 采用数组空间SQ.base[0,n-1]存放其元素值,已知其头尾指针分别是front 和rear,则判定此循环队 列为满的条件是() A、Q.front==Q.rear B、Q.front!=Q.rear C、Q.front==(Q.rear+1)%n D、Q.front!=(Q.rear+1)%n 10.若在一个大小为6 的数组上实现循环队列,且当前rear 和front 的值分别为0 和3,当从队列中删除一个元素, 再加入两个元素后,rear 和front 的值分别为() A、1,5 B、2, 4 C、4,2 D、5,1 11.用单链表表示的链式队列的队头在链表的()位置 A、链头 B、链尾 C、链中 12.判定一个链队列Q(最多元素为n 个)为空的条件是() A、Q.front==Q.rear B、Q.front!=Q.rear C、Q.front==(Q.rear+1)%n D、Q.front!=(Q.rear+1)%n 13.在链队列Q 中,插入s 所指结点需顺序执行的指令是() A 、Q.front->next=s;f=s; B 、Q.rear->next=s;Q.rear=s; C 、s->next=Q.rear;Q.rear=s; D 、s->next=Q.front;Q.front=s; 14.在一个链队列Q 中,删除一个结点需要执行的指令是() A、Q.rear=Q.front->next; B、Q.rear->next=Q.rear->next->next; C、Q.front->next=Q.front->next->next; D、Q.front=Q.rear->next;

循环队列,出队,入队

数据结构循环队列的顺序结构实现以及队列的初始化、入队、出队等基本操作函数 2009-11-15 15:09

#include #include #define max 50 //队列的数据结构 typedef struct { int element[max];//队列的元素空间 int front;//头指针指示器 int rear;//尾指针指示器 }SeqQueue; //函数声明表 void Print(SeqQueue *Q); void Choose(int choice,SeqQueue *Q); void InitQueue(SeqQueue *Q); int EnterQueue(SeqQueue *Q,int x); int DeleteQueue(SeqQueue *Q,int *x);

void PrintQueue(SeqQueue *Q); //主函数 int main() { SeqQueue Q; InitQueue(&Q); system("color a");//系统变色为浅绿 Print(&Q); while(true) { printf("Press enter to continue........."); getchar(); getchar(); system("cls"); Print(&Q); } return 0; } //重复刷新并打印功能选项列表来模拟面向对象编程的等待命令操作 void Print(SeqQueue *Q) { int choice; printf("Made By 杨梅树的盔甲~O(∩_∩)O~\n"); printf("---------------------\n"); printf("使用说明:本程序可实现顺序结构构建队列及队列的初始化、入队、出队等基本操作.\n"); printf("---------------------\n"); printf("1.入队.\n"); printf("2.出队.\n"); printf("3.打印输出当前队列.\n"); printf("4.按其它任意键退出.\n"); printf("---------------------\n"); printf("请选择你要的操作:"); scanf("%d",&choice); Choose(choice,Q); } //选择功能函数 void Choose(int choice,SeqQueue *Q)

PTA第三章栈和队列练习题

1-1 通过对堆栈S操作:Push(S,1), Push(S,2), Pop(S), Push(S,3), Pop(S), Pop(S)。输出的序列为:123。(2分) T F 作者: DS课程组 单位: 浙江大学 1-2 在用数组表示的循环队列中,front值一定小于等于rear值。(1分) T F 作者: DS课程组 单位: 浙江大学 1-3 若一个栈的输入序列为{1, 2, 3, 4, 5},则不可能得到{3, 4, 1, 2, 5}这样的出栈序列。(2分) T F 作者: 徐镜春 单位: 浙江大学 1-4 If keys are pushed onto a stack in the order {1, 2, 3, 4, 5}, then it is impossible to obtain the output sequence {3, 4, 1, 2, 5}. (2分) T F 作者: 徐镜春 单位: 浙江大学 1-5 所谓“循环队列”是指用单向循环链表或者循环数组表示的队列。(1分) T F 作者: DS课程组 单位: 浙江大学 1-6 An algorithm to check for balancing symbols in an expression uses a stack to store the symbols. (1分) T F 2-1 设栈S和队列Q的初始状态均为空,元素a、b、c、d、e、f、g依次进入栈S。若每个元素出栈后立即进入队列Q,且7个元素出队的顺序是b、d、c、f、e、a、g,则栈S的容量至少是:(2分)

1. 1 2. 2 3. 3 4. 4 作者: DS课程组 单位: 浙江大学 2-2 若元素a、b、c、d、e、f依次进栈,允许进栈、退栈操作交替进行,但不允许连续三次进行退栈工作,则不可能得到的出栈序列是?(2分) 1. b c a e f d 2. c b d a e f 3. d c e b f a 4. a f e d c b 作者: DS课程组 单位: 浙江大学 2-3 设一个栈的输入序列是1、2、3、4、5,则下列序列中,是栈的合法输出序列的是?(2分) 1. 3 2 1 5 4 2. 5 1 2 3 4 3. 4 5 1 3 2 4. 4 3 1 2 5

第三章+栈和队列(参考答案)

第三章栈和队列 一、判断题 1、链栈的初始化是指开辟足够多的结点,然后置栈顶指针为 NULL。(×) 2、递归定义的数据结构通常不需要用递归的算法来实现对它的操作。(×) 二、填空题 1、向一个链式栈插入一个新结点时,首先把栈顶指针的值赋给新结点的指针域,然后把新结点的存储位置赋给___栈顶指针_____。 2、迷宫问题是一个回溯控制的问题,最好使用____栈______的方法来解决。 3、有如下递归过程: Void Print(int w) { int i; if (w!=0) { Print(w?1); for (i=1;i<=w;i++) printf(“%3d”,w); printf(“\n”); } } 调用语句print(4)的结果是__________。 1 2 2 3 3 3 4 4 4 4 4、假设用循环单链表实现队列,若队列非空,且队尾指针为R, 则将新结点S加入队列时,需执行下面语句:_ S->next=R->next _________;___ R->next=S _______;R=S; 三、选择题 1、设有4个数据元素a1、a 2、a3和a4,对他们分别进行栈操作或队操作。在进栈或进队操作时,按a1、a2、a 3、a4次序每次进入一个元素。假设栈或队的初始状态都是空。 现要进行的栈操作是进栈两次,出栈一次,再进栈两次,出栈一次;这时,第一次出栈得到的元素是 A 2,第二次出栈得到的元素是 B 4;类似地,考虑对这四个数据元素进行的队操作是进队两次,出队一次,再进队两次,出队一次;这时,第一次出队得到的元素是 C 1,第二次出队得到的元素是 D 2。经操作后,最后在栈中或队中的元素还有 E 2个。 供选择的答案: A~D:①a1 ②a2 ③ a3 ④a4 E:①1 ②2 ③ 3 ④ 0 2、栈是一种线性表,它的特点是 A 2。设用一维数组A[1,…,n]来表示一个栈,A[n]为栈底,用整型变量T指示当前栈顶位置,A[T]为栈顶元素。往栈中推入(PUSH)一个新元素时,变量T的值 B 2;从栈中弹出(POP)一个元素时,变量T的值 C 1。设栈空时,有输入序列a,b,c,经过PUSH,POP,PUSH,PUSH,POP操作后,从栈中弹出的元素的序列是 D 6,变量T的值是 E 4。 供选择的答案: A:①先进先出②后进先出③进优于出④出优于进⑤随机进出 B,C:①加1 ②减1 ③不变④清⑤加2 ⑥减2 D:① a,b ②b,c ③c,a ④b,a ⑤ c,b ⑥a,c E:① n+1 ②n+2 ③ n ④ n-1 ⑤ n-2 3、在做进栈运算时,应先判别栈是否 A 2;在做退栈运算时,应先判别栈是否 B 1。当栈中元素为n个,做进栈运算时发生上溢,则说明该栈的最大容量为 C 2。

循环队列实现数据的入队与出对程序算法

#include #include #define maxlen 11 typedef struct{ int data[maxlen]; int front; int rear; }seqqueue; seqqueue *seq() { seqqueue *Q; Q=(seqqueue *)malloc(sizeof(seqqueue)); Q->front=0; Q->rear=0; return Q; } int full(seqqueue *Q){ if(Q->front==(Q->rear+1)%maxlen) return 1; else return 0; } int empty(seqqueue *Q){ if (Q->front==Q->rear) return 1; else return 0; } void add(seqqueue *Q,int x) { if(!full(Q)) { Q->rear=(Q->rear+1)%maxlen; Q->data[Q->rear]=x; } else printf("queue full!"); } void del(seqqueue *Q) { if(!empty(Q)) Q->front=(Q->front+1)%maxlen; else printf("queue empty");

} int length(seqqueue *Q) { int a; a=(Q->rear-Q->front+maxlen)%maxlen; return a; } void out(seqqueue *Q) { int i,j,y; j=length(Q); for(i=1;ifront+i)%maxlen; printf("%3d",Q->data[y]); } } void main() { seqqueue Q; int i,x,n; Q=*seq(); printf("该循环最多存放10个数。\n"); printf("请输入你要输入元素的个数:"); scanf("%d",&n); printf("请输入%d个元素:",n); for(i=0;i

循环队列的操作和实现C语言

循环队列的基本操作都可以实现,后面有代码。

代码: #include #include #include #include #define MAX_SIZE 10//定义循环队列的长度typedef struct{ int*base; int front; int rear; int full;//队列是否已满的标志位}Queue; int creat_queue(Queue*q); int en_queue(Queue*q,int e); int out_queue(Queue*q,int*e); int destroy_queue(Queue*q); int length_queue(Queue*q);

void main() { Queue q; int m,n,i,e,f,f1,k=0; int a1,a2,a3,a4,a5,a6;//用来接函数返回值 int *e1,*e2; q.base=NULL; e1=e2=&k;//对于指针最好这样初始化定义一下,因为只声明是没有分陪内存的,不能直接用*e printf("----------------循环队列的基本操作---------------\n"); printf("----------------1.创建一个空队列-----------------\n"); printf("----------------2.单次入队列---------------------\n"); printf("----------------3.单次出队列---------------------\n"); printf("----------------4.集体入队列---------------------\n"); printf("----------------5.集体出队列---------------------\n"); printf("----------------6.队列元素个数-------------------\n"); printf("----------------7.销毁队列-----------------------\n"); printf("----------------0.退出---------------------------\n"); loop: printf("请选择:"); scanf("%d",&m); switch(m) { case 1: a1=creat_queue(&q); if(a1==0) { printf("队列已经存在,请先销毁原来队列!\n"); break;} printf("OK!队列创建成功!\n"); break; case 2: printf("请输入要入队列的元素(整型):"); scanf("%d",&e); a2=en_queue(&q,e); if(a2==-1) { printf("队列不存在,请先创建队列!\n"); break; } else if(a2==0) { printf("入队失败!因为队列满了!\n"); break; } else { printf("OK!入队成功!\n"); break; } case 3: a3=out_queue(&q,e1);

队列的入队出队初始化操作

实践考核题第一题设计报告书 学生姓名 XXX 学生学号099XXX 所在地区XXX 提交日期(年/月)2014/6 实践题目利用队列的结构解决实际问题 需求分析 置空函数:根据函数的形参,即传递进来的队列指针,调用它的首指针和尾指针让两个指针相等,就把队列中的元素全部清空。 入队函数:首先判断该队列是否已满,如果队列已满,就退出操作。否则, 执行入队操作的语句,由于是循环队列所以在移动尾指针时,要把尾指针的位置取余运算(queue.rear=(queue.rear+1)%maxsize;),然后把数据元素赋给尾指针(queue,data[queue.rear]=x;)。 出队函数:当有数据元素要出队时,首先判断该队列是否为空,如果为空 时,元素出队列失败。否则,当队列不为空时,执行出队操作(queue.front=(queue.front+1)%maxsize;)返回数值1,说明出队成功。 判空函数:该函数是用来判断队列是否为空的,是被别的函数调用作为判 断条件用,若果为空的话就返回数值0,标志不能继续执行下面的语句。判断为空的条件是:queue.rear==queue.front;如果为空返回值为1,否则返回值为0。 概要设计 1)置空 setnull ( queue ) 将队列 queue 置成空队列 调用setnull(queue)函数把队列queue的顶端指针和低端指针指向同一块地址,这样就把队列置空。当队列中的数据元素不用或者必须要清楚的时候,就必须调用该函数把队列中的数据清空才能在插入新的数据供用户操作使用。 2)入队 enqueue ( queue , x ) 将元素 x 插入队列 queue 的尾

循环队列进队、出队、浏览

//3、用数组实现整数循环队列,编写进队、出队、浏览队中全部内容的示意程序。 #include #define QueueSize 10 typedef int DataType; typedef struct { int front; int rear; int count; DataType data[QueueSize]; } CirQueue; //1、置队空 void initQueue(CirQueue *Q) { Q->front = Q->rear = 0; Q->count = 0; } //2、判队空 int queueEmpty(CirQueue *Q) { return Q->count == 0; } //3、判队满 int queueFull(CirQueue *Q) { return Q->count == QueueSize; } //4、入队 void enQueue(CirQueue *Q, DataType x) { if(queueFull(Q)) { printf("队满\n"); return ; } Q->count++; Q->data[Q->rear] = x; Q->rear = (Q->rear+1)%QueueSize; } //5、出队

DataType deQueue(CirQueue *Q) { DataType temp; if(queueEmpty(Q)) { printf("队空\n"); return -1; } temp = Q->data[Q->front]; Q->count--; Q->front = (Q->front+1)%QueueSize; return temp; } //6、访问队头元素 DataType queueFront(CirQueue *Q) { if(queueEmpty(Q)) { printf("队空\n"); return -1; } return Q->data[Q->front]; } void travelQueue(CirQueue *Q) { int p = Q->front, k; if(queueEmpty(Q)) printf("队空\n"); for(k = Q->count; k > 0; k--) { printf("%d\n", Q->data[p]); p = (p+1)%QueueSize; } } CirQueue queue; void main() { DataType b; int ans; while (1) { printf("请选择命令!\n"); printf("\t1:建立空队;\n"); printf("\t2:一个指定值进队;\n"); printf("\t3:从队中退出一个队元;\n"); printf("\t4:浏览队中全部内容;\n"); printf("\t其它选择结束程序!\n"); printf("\t\t选择? "); scanf("%d", &ans); if (ans < 1 || ans > 4) break; if(ans == 2) {

循环队列(完整可运行代码)

1)顺序循环队列类型定义为: #define N 20typedef struct { int data[N]; int front, rear; }queue_type; 2)编写循环队列出队函数dequeue 3)编写循环队列入队函数enqueue 4)编写函数:void aa(queue_type *q); 调用出对函数把队列q中的元素一一出对列,如果是负数直接抛弃;如果是正数,则调用入队函数,插入到q的队尾。5)编写main函数,首先建立一个队列,其中的数据元素为:{2, 3, -4, 6, -5, 8, -9, 7, -10, 20};然后调用aa函数,并将aa函数调用前后队列的数据元素分别输出到屏幕上。 #include #define N 20 typedef int elemtype; int count; typedef struct queue_type { elemtype data[N]; int front; int rear; }queue_type; void initqueue(queue_type *q) { q->front=q->rear=0; return; } int enqueue(queue_type *q,elemtype x) { if((q->rear+1) % N == q->front) return 0; else { q->rear=(q->rear+1)%N; q->data[q->rear]=x; return(true); } } int dequeue(queue_type *q,elemtype *x)

队列的顺序存储(循环队列)

第9讲队列的顺序存储(循环队列) 1. 顺序队列的假溢出现象 队列的一种顺序存储称为顺序队列。与顺序栈类似,在队列的顺序存储结构中,用一组地址连续的存储单元依次存放从队头到队尾的元素,如一维数组Queue[MAXSIZE]。 由于队列中队头和队尾的位置都是动态变化的,因此需要附设两个指针front 和rear 。 front:指示队头元素在数组中的位置; rear:指示真实队尾元素相邻的下一个位置。 初始化队列时,令front = rear =0;入队时,直接将新元素送入尾指针rear 所指的单元,然后尾指针增1;出队时,直接取出队头指针front 所指的元素,然后头指针增1。显然,在非空顺序队列中,队头指针始终指向当前的队头元素,而队尾指针始终指向真正队尾元素后面的单元。当rear==MAXSIZE 时,认为队满。但此时不一定是真的队满,因为随着部分元素的出队,数组前面会出现一些空单元,如下图(d)所示。由于只能在队尾入队,使得上述空单元无法使用。把这种现象称为假溢出,真正队满的条件是rear - front=MAXSIZE 。 2. 循环队列 为了解决假溢出现象并使得队列空间得到充分利用,一个较巧妙的办法是将顺序队列的数组看成一个环状的空间,即规定最后一个单元的后继为第一个单元,我们形象地称之为循环队列。假设队列数组为Queue[MAXSIZE],当rear+1=MAXSIZE 时,令rear=0,即可求得最后一个单元Queue[MAXSIZE-1]的后继:Queue[0]。更简便的办法是通过数学中的取模(求余)运算来实现:rear=(rear+1)mod MAXSIZE ,显然,当rear+1=MAXSIZE 时,rear=0,同样可求得最后一个单元Queue[MAXSIZE-1]的后继:Queue[0]。所以,借助于取模(求余)运算,可以自动实现队尾指针、队头指针的循环变化。进队操作时,队尾指针的变化是:rear=(rear+1)mod MAXSIZE ;而出队操作时,队头指针的变化是:front=(front+1)mod MAXSIZE 。 下图给出了循环队列的几种情况。 【循环队列判空判满问题】与一般的非空顺序队列相同,在非空循环队列中,队头指针顺序队列的基本操作示意图 front rear front rear front rear front rear (a ) 空队列 (b ) a ,b,c,d 入队 (c ) a,b,c 出队 (d ) e,f 入队

相关文档
最新文档