链式队列的基本操作

链式队列的基本操作
链式队列的基本操作

#include

#include

typedef char ElemType;

typedef struct QNode

{

ElemType data;

struct QNode *next;

}QNode,*QueuePtr;

typedef struct

{

QueuePtr front;

QueuePtr rear;

}LinkQueue;//链式队列

//初始化

LinkQueue InitQueue()

{

LinkQueue Q;

Q.rear=(QNode *)malloc(sizeof(QNode));

Q.front =Q.rear;

if(Q.front ==NULL) printf("内存分配失败\n");

else {Q.front->next=NULL;return Q;}

//判断链栈是否为空

int QueueEmpty(LinkQueue Q)

{

if(Q.front->next==NULL) return 1;

else return 0;

}

//求链式队列长度

int QueueLength(LinkQueue Q) {

int count=0;

QNode *s;

s=Q.front->next ;

while(s!=NULL)

{

count++;

s=s->next ;

}

return count;

}

//元素入队

int EnQueue(LinkQueue &Q,ElemType e) {

QNode *s;

s=(QNode *)malloc(sizeof(QNode));

if(!s) {printf("内存分配失败\n");return 0;} else

{

s->data =e;

s->next =NULL;

Q.rear->next =s;

Q.rear =s;

return 1;

}

}

//元素出队

int DeQueue(LinkQueue &Q,ElemType &e) {

QNode *s;

if(Q.front==Q.rear)

{

printf("队列已空\n");

return 0;

}

else

{

s=Q.front->next ;

e=s->data ;

Q.front->next =s->next ;

if(Q.rear==s) Q.rear =Q.front ;

free(s);

return 1;

}

}

//取队头元素

int GetHead(LinkQueue Q,ElemType &e)

{

QNode *s;

if(Q.front ==Q.rear ){printf("队列已空\n");return 0;} else

{

s=Q.front->next;

e=s->data ;

return 1;

}

}

//清空队列

void ClearQueue(LinkQueue &Q) {

while(Q.front !=NULL )

{

Q.rear =Q.front->next ;

free(Q.front );

Q.front =Q.rear;

}

}

//遍历队列

void QueueTraverse(LinkQueue Q) {

QNode *s;

ElemType e;

s=Q.front->next ;

while(s)

{

e=s->data;

printf("%c ",e);

s=s->next;

}

}

int scan()

{

int d;

printf("\n\n\n\n请输入要进行的操作\n1.初始化一个链式队列\n2.清空队列\n3.求队列长度\n4.检查队列是否为空\n5.取队头元素\n6.元素入队\n7.元素出队\n8.输出队列所有元素\n 其他键退出...\n");

scanf("%d",&d);

return (d);

}

int main()

{

int quit=0;

ElemType e;

LinkQueue Q;

while(!quit)

switch(scan())

{

case 1:Q=InitQueue();printf("\n");break;

case 2:ClearQueue(Q);printf("\n");break;

case 3:printf("队列的长度为:%d\n",QueueLength(Q));break;

case 4:if(QueueEmpty(Q))printf("队列为空\n");else printf("队列非空\n");break;

case 5:if(GetHead(Q,e)) printf("队头元素为:%c",e);else break;break;

case 6:printf("请输入要入队的元素:");getchar();scanf("%c",&e);if(EnQueue(Q,e)) printf("%c已入队\n",e);break;

case 7:if(DeQueue(Q,e)) printf("%c已出队\n",e);break;

case 8:QueueTraverse(Q);break;

default:quit=1;

}

return 0;

}

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

链队列的基本操作(创建,销毁,查找,删除,插入等)#include using namespace std; const bool TRUE=1 ; const bool FALSE=0; typedef int QElemType; typedef struct LNode { QElemType data; struct LNode *next; }LNode ,*LinkList; typedef LinkList QueuePtr; typedef struct{ QueuePtr front; QueuePtr rear; }LinkQueue; void InitQueue_L(LinkQueue &Q) {//构造一个只有头结点的空队列Q 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; Q.front=Q.rear; }//while }// DestroyQueue_L bool QueueEmpty_L(LinkQueue Q) {//判断队列是否为空,是则返回TRUE,否则返回FALSE if(Q.front==Q.rear)return TRUE; else return FALSE; }//QueueEmpty int QueueLength(LinkQueue Q)

数据结构(C语言)队列的基本操作

实验名称:实验四队列的基本操作 实验目的 掌握队列这种抽象数据类型的特点及实现方法。 实验内容 从键盘读入若干个整数,建一个顺序队列或链式队列,并完成下列操作: (1)初始化队列; (2)队列是否为空; (3)出队; (4)入队。 算法设计分析 (一)数据结构的定义 单链表存储结构定义为: struct Node; //链表单链表 typedef struct Node *PNode; int dui; dui =1; struct Node { int info; PNode link; }; struct LinkQueue { PNode f; PNode r; }; typedef struct LinkQueue *PLinkQueue; (二)总体设计 程序由主函数、创建队列函数、判断是否为空队列函数、入队函数、出队函数、取数函数、显示队列函数、菜单函数组成。其功能描述如下: (1)主函数:调用各个函数以实现相应功能 main() { PLinkQueue a; //定义链表a int b,c,e; //b 菜单选择c选择继续输入e输入元素 do { //菜单选择 mune(); scanf("%d",&b);

switch(b) { case 1://初始化 a=create(); //初始化队列 case 2: //入队 do { printf("\n请输入需要入队的数:"); if(e!=NULL) { scanf("%d",&e); enQueue(a,e); } printf("是否继续入队?(是:1 否:0)\n"); scanf("%d",&c); } while(c==1); break; case 3: //出队 c=frontQueue(a); deQueue(a); if(dui!=0) { printf("\n出队为:%d\n",c); } dui=1; break; case 4: //显示队中元素 showQueue(a); break; case 5: return; default: printf("输入错误,程序结束!\n"); return; } } while(a!=5); { return 0; } } (三)各函数的详细设计: Function1: PLinkQueue create(void)//创队

队列的基本操作代码

队列的基本操作代码: #include #include #define MAXQSIZE 100 #define OVERFLOW 0 #define ERROR 0 #define OK 1 typedef int QElemType; typedef int Status; typedef struct { QElemType *base; int front; int rear; int tag; }SqQueue; Status InitQueue(SqQueue &Q) { Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base) exit(OVERFLOW);//存储分配失败 Q.front=Q.rear=0; tag=0; return OK; } int QueueLength(SqQueue Q) { return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;//返回Q的元素个数,即队列的长度} Status EnQueue(SqQueue &Q,QElemType e) { if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;//队列满 Q.base[Q.rear]=e; Q.rear=(Q.rear+1)%MAXQSIZE; return OK; } Status DeQueue(SqQueue &Q,QElemType &e) { if(Q.front==Q.rear) return ERROR; e=Q.base[Q.front];

栈和队列的基本操作

《数据结构与算法》实验报告 专业班级学号 实验项目 实验二栈和队列的基本操作。 实验目的 1、掌握栈的基本操作:初始化栈、判栈为空、出栈、入栈等运算。 2、掌握队列的基本操作:初始化队列、判队列为空、出队列、入队列等运算。 实验容 题目1: 进制转换。利用栈的基本操作实现将任意一个十进制整数转化为R进制整数 算法提示: 1、定义栈的顺序存取结构 2、分别定义栈的基本操作(初始化栈、判栈为空、出栈、入栈等) 3、定义一个函数用来实现上面问题: 十进制整数X和R作为形参 初始化栈 只要X不为0重复做下列动作 将X%R入栈 X=X/R 只要栈不为空重复做下列动作 栈顶出栈输出栈顶元素 题目2: 利用队列的方式实现辉三角的输出。 算法设计分析 (一)数据结构的定义 1、栈的应用 实现十进制到其他进制的转换,该计算过程是从低位到高位顺序产生R进制数的各个位数,而打印输出一般从高位到低位进行,恰好与计算过程相反。因此,运用栈先进后出的性质,即可完成进制转换。 栈抽象数据结构描述 typedef struct SqStack /*定义顺序栈*/ { int *base; /*栈底指针*/ int *top; /*栈顶指针*/ int stacksize; /*当前已分配存储空间*/ } SqStack;

2、队列的应用 由于是要打印一个数列,并且由于队列先进先出的性质,肯定要利用已经进队的元素在其出队之前完成辉三角的递归性。即,利用要出队的元素来不断地构造新的进队的元素,即在第N行出队的同时,来构造辉三角的第N+1行,从而实现打印辉三角的目的。 队列抽象数据结构描述 typedef struct SeqQueue { int data[MAXSIZE]; int front; /*队头指针*/ int rear; /*队尾指针*/ }SeqQueue; (二)总体设计 1、栈 (1)主函数:统筹调用各个函数以实现相应功能 int main() (2)空栈建立函数:对栈进行初始化。 int StackInit(SqStack *s) (3)判断栈空函数:对栈进行判断,若栈中有元素则返回1,若栈为空,则返回0。 int stackempty(SqStack *s) (4)入栈函数:将元素逐个输入栈中。 int Push(SqStack *s,int x) (5)出栈函数:若栈不空,则删除栈顶元素,并用x返回其值。 int Pop(SqStack *s,int x) (6)进制转换函数:将十进制数转换为R进制数 int conversion(SqStack *s) 2、队列 (1)主函数:统筹调用各个函数以实现相应功能 void main() (2)空队列建立函数:对队列进行初始化。 SeqQueue *InitQueue() (3)返回队头函数:判断队是否为空,若不为空则返回队头元素。 int QueueEmpty(SeqQueue *q) (4)入队函数:将元素逐个输入队列中。 void EnQueue(SeqQueue *q,int x) (5)出队函数:若队列不空,则删除队列元素,并用x返回其值。 int DeQueue(SeqQueue *q) (6)计算队长函数:计算队列的长度。 int QueueEmpty(SeqQueue *q) (7)输出辉三角函数:按一定格式输出辉三角。 void YangHui(int n)

队列的基本操作及其应用

广西工学院计算机学院 《数据结构》课程实验报告书实验四队列的基本操作及其应用 学生姓名:李四 学号:2012 班级:计Y124 指导老师:王日凤 专业:计算机学院软件学院 提交日期:2013年6月20日

1.实验目的 1)通过对队列特点的分析,掌握队列的存储结构及其基本操作,学会定义队列的顺序存储结构和链式存储结构,在实际问题中灵活运用。 2)掌握队列先进先出的特点,掌握队列的基本操作,如出队列、入队列、判队列空、判队列满等,熟悉各种操作的实现方法。 3)通过具体的应用实例,进一步熟悉和掌握队列的实际应用。 2.实验内容 (1)建立一个含n个数据的队列,实现队列的基本操作。包括: ?//1. 初始化,构造一个空队列 void initQueue(Queue &Q) ?//2. 判断队列空, 空则返回true bool QueueEmpty(seqQueue &Q) ?//3. 判断队列满, 满则返回true bool QueueFull(seqQueue &Q) ?//4. 取队头元素, 用x返回队头元素,返回true;空队列则返回false Bool QueueHead(seqQueue &Q, elementType &x) ?//5. 入队列,在队尾插入新元素x (流程图) bool pushQueue (seqQueue &Q, elementType x) ?//6. 出队列,用x带回队头元素,并在队头删除,返回true,队列空则返回false(流程图)bool popQueue (seqQueue &Q, elementType &x) ?//7. 输出队列,从队头到队尾依次输出 void printQueue(seqQueue Q) (2)队列应用:利用队列操作打印杨辉三角形的前n行(如n=7)。 3.实验要求 (1)上机前交实验源程序(纸质版),由学习委员统一收好交老师(附上不交同学名单)。 (2)用一切你能想到的办法解决遇到的问题,培养解决问题的能力。 (3)实验课上进行答辩。 (4)实验报告当场交。报告内容包括:实验目的、实验内容、实验代码、实验输入输出结果以及实验体会供五部分。

栈和队列的基本操作的实现

封面: 安徽大学 网络工程 栈和队列的基本操作的实现 ______2010\4\12

【实验目的】 1.理解并掌握栈和队列的逻辑结构和存储结构; 2.理解栈和队列的相关基本运算; 3.编程对相关算法进行验证。 【实验内容】 (一)分别在顺序和链式存储结构上实现栈的以下操作(含初始化,入栈,出栈,取栈顶元素等): 1.构造一个栈S,将构造好的栈输出; 2.在第1步所构造的栈S中将元素e 入栈,并将更新后的栈S输出; 3.在第2步更新后所得到的栈S中将栈顶元素出栈,用变量e返回该元素,并将更新后的栈S输出。(二)分别在链队列和循环队列上实现以下操作(初始化,入队,出队,取队头元素等): 1.构造一个队列Q,将构造好的队列输出; 2.在第1步所构造的队列Q中将元素e入队,并将更新后的队列Q输出; 3.在第2步更新后所得到的队列Q中将队头元素出队,用变量e返回该元素,并将更新后的队列Q输出。

【要求】 1.栈和队列中的元素要从终端输入; 2.具体的输入和输出格式不限; 3.算法要具有较好的健壮性,对运行过程中的错误 操作要做适当处理。 三、实验步骤 1.本实验用到的数据结构 (1)逻辑结构:线性结构 (2)存储结构:程序一、四(顺序存储结构); 程序二、三(链式存储结构); 2.各程序的功能和算法设计思想 程序一:顺序栈 # include # include # include #define STACKINITISIZE 100 # define STACKINCREMENT 10 # define OK 1 # define ERROR 0 # define OVERFLOW -2 typedef int SElemtype; typedef int status; typedef struct { SElemtype *base; SElemtype *top; int stacksize; }sqstack; void Initstack (sqstack *s) { (*s).base = (SElemtype *)malloc(STACKINITISIZE * sizeof (SElemtype)); if(!(*s).base) exit(OVERFLOW);

试验 --循环队列的基本操作及应用

数据结构实验报告 ----试验三循环队列的基本操作及应用 一、问题描述: 熟悉并掌握循环队列的相关操作,自己设计程序,实现循环队列的构造、清空、销毁及队列元素的插入和删除等相关操作。 二、数据结构设计: #define MAXQSIZE 10 //最大队列长度 struct SqQueue { QElemType *base; //初始化动态分配存储空间 Int front; // 头指针,若队列不空,只想对列头元素 int rear; //尾指针,若队列不空,指向队列尾元素的 //下一个位置 }; 三、功能设计: 程序中所涉及到的函数如下: Status InitQueue(SqQueue &Q) //构造一个空队列Q Status DestroyQueue(SqQueue &Q) //销毁队列Q,Q不再存在 Status ClearQueue(SqQueue &Q) //将Q清为空队列 Status QueueEmpty(SqQueue Q) //若队列Q为空队列,则 //返回TRUE,否则返回FALSE int QueueLength(SqQueue Q) //返回Q的元素个数,即队列长度Status GetHead(SqQueue Q,QElemType &e)//若队列不空,则用e返回Q的对 //头元素,并返回OK,否则返回ERROR Status EnQueue(SqQueue &Q,QElemType e)//插入元素e为Q的新的队尾元素Status DeQueue(SqQueue &Q,QElemType &e)//若队列不空,则删除Q的队头 //元素,用e返回其值,并返回 //OK,否则返回ERROR Status QueueTraverse(SqQueue Q,void(*vi)(QElemType))//从队头到队尾依次 //对队列Q中每个元素调用函数 //vi()。一旦vi失败,则操作失败四、源程序: // c1.h (程序名) #include #include #include // malloc()等 #include // INT_MAX等 #include // EOF(=^Z或F6),NULL

数据结构第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.对链栈不作任何判别

栈和队列的基本操作实现及其应用

实验二栈和队列的基本操作实现及其应用 一_一、实验目的 1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。 一_二、实验内容 题目一、试写一个算法,判断依次读入的一个以@为结束符的字符序列,是否为回文。所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。 相关常量及结构定义: #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef int SElemType; typedef struct SqStack { SElemType *base; SElemType *top; int stacksize; }SqStack; 设计相关函数声明: 判断函数:int IsReverse() 栈:int InitStack(SqStack &S )

int Push(SqStack &S, SElemType e ) int Pop(SqStack &S,SElemType &e) int StackEmpty(s) 一_三、数据结构与核心算法的设计描述 1、初始化栈 /* 函数功能:对栈进行初始化。参数:栈(SqStack S)。 成功初始化返回0,否则返回-1 */ int InitStack(SqStack &S) { S.base=(SElemType *)malloc(10*sizeof(SElemType)); if(!S.base) //判断有无申请到空间 return -1; //没有申请到内存,参数失败返回-1 S.top=S.base; S.stacksize=STACK_INIT_SIZE; S.base=new SElemType; return 0; } 2、判断栈是否是空 /*函数功能:判断栈是否为空。参数; 栈(SqStack S)。栈为空时返回-1,不为空返回0*/ int StackEmpty(SqStack S) { if(S.top==S.base) return -1; else return 0; } 3、入栈 /*函数功能:向栈中插入元素。参数; 栈(SqStack S),元素(SElemtype e)。成功插入返回0,否则返回-1 */ int Push(SqStack &S,SElemType e) { if(S.top-S.base>=S.stacksize) { S.base=(SElemType *)realloc(S.base,(S.stacksize+1) * sizeof(SElemType));

《数据结构》习题汇编03第三章栈和队列试题

第三章栈和队列试题 一、单项选择题 1.栈的插入和删除操作在()进行。 A. 栈顶 B. 栈底 C. 任意位置 D. 指定位置 2.当利用大小为n的数组顺序存储一个栈时,假定用top==n表示栈空,则向这个栈插入一个元素时, 首先应执行()语句修改top指针。 A. top++; B. top--; C. top = 0; D. top; 3.若让元素1,2,3依次进栈,则出栈次序不可能出现()种情况。 A. 3, 2, 1 B. 2, 1, 3 C. 3, 1, 2 D. 1, 3, 2 4.在一个顺序存储的循环队列中,队头指针指向队头元素的()位置。 A. 前一个 B. 后一个 C. 当前 D. 后面 5.当利用大小为n的数组顺序存储一个队列时,该队列的最大长度为()。 A. n-2 B. n-1 C. n D. n+1 6.从一个顺序存储的循环队列中删除一个元素时,需要()。 A. 队头指针加一 B. 队头指针减一 C. 取出队头指针所指的元素 D. 取出队尾指针所指的元素 7.假定一个顺序存储的循环队列的队头和队尾指针分别为front和rear,则判断队空的条件为()。 A. front+1 == rear B. rear+1 == front C. front == 0 D. front == rear 8.假定一个链式队列的队头和队尾指针分别为front和rear,则判断队空的条件为()。 A. front == rear B. front != NULL C. rear != NULL D. front == NULL 9.设链式栈中结点的结构为(data, link),且top是指向栈顶的指针。若想在链式栈的栈顶插入一 个由指针s所指的结点,则应执行操作()。 A. top->link = s; B.s->link = top->link; top->link = s; C. s->link = top; top = s; D. s->link = top; top = top->link; 10.设链式栈中结点的结构为(data, link),且top是指向栈顶的指针。若想摘除链式栈的栈顶结点, 并将被摘除结点的值保存到x中,则应执行操作()。 A. x = top->data; top = top->link; B. top = top->link; x = top->data; C. x = top; top = top->link; D. x = top->data; 11.设循环队列的结构是 #define MaxSize 100 typedef int ElemType;

数据结构 栈和队列的基本操作实现及其应用

实验二栈和队列的基本操作实现及其应用 一、实验目的 1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。 2、会用栈和队列解决简单的实际问题。 二、实验内容(可任选或全做) 题目一、试写一个算法,判断依次读入的一个以@为结束符的字符序列, 是否为回文。所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。 相关常量及结构定义: # define STACK_INIT_SIZE 100 # define STACKINCREMENT 10 # define OK 1 # define ERROR 0 typedef int SElemType; //栈类型定义 typedef struct SqStack { SElemType *base; SElemType *top; int stacksize; }SqStack; 设计相关函数声明: 判断函数:int IsReverse() 栈:int InitStack(SqStack &S ) int Push(SqStack &S, SElemType e ) int Pop(SqStack &S,SElemType &e) int StackEmpty(s) 题目二、编程模拟队列的管理,主要包括: 出队列、 入队、 统计队列的长度、 查找队列某个元素e、 及输出队列中元素。 [实现提示]:参考教材循环队列的有关算法,其中后两个算法参考顺序表的实现。 题目三、Rails

Description There is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited that time. It was possible to establish only a surface track. Moreover, it turned out that the station could be only a dead-end one (see picture) and due to lack of available space it could have only one track. The local tradition is that every train arriving from the direction A continues in the direction B with coaches reorganized in some way. Assume that the train arriving from the direction A has N <= 1000 coaches numbered in increasing order 1, 2, ..., N. The chief for train reorganizations must know whether it is possible to marshal coaches continuing in the direction B so that their order will be a1, a2, ..., aN. Help him and write a program that decides whether it is possible to get the required order of coaches. You can assume that single coaches can be disconnected from the train before they enter the station and that they can move themselves until they are on the track in the direction B. You can also suppose that at any time there can be located as many coaches as necessary in the station. But once a coach has entered the station it cannot return to the track in the direction A and also once it has left the station in the direction B it cannot return back to the station. Input The input consists of blocks of lines. Each block except the last describes one train and possibly more requirements for its reorganization. In the first line of the block there is the integer N described above. In each of the next lines of the block there is a permutation of 1, 2, ..., N. The last line of the block contains just 0. The last block consists of just one line containing 0. Output

栈和队列答案

栈和队列 一选择题 1. 对于栈操作数据的原则是()。 A. 先进先出 B. 后进先出 C. 后进后出 D. 不分顺序 2. 在作进栈运算时,应先判别栈是否( ①B ),在作退栈运算时应先判别栈是否( ②A)。当栈中元素为n个,作进栈运算时发生上溢,则说明该栈的最大容量为( ③ )。为了增加内存空间的利用率和减少溢出的可能性,由两个栈共享一片连续的内存空间时,应将两栈的( ④ )分别设在这片内存空间的两端,这样,当( ⑤ )时,才产生上溢。 ①, ②: A. 空 B. 满 C. 上溢 D. 下溢 ③: A. n-1 B. n C. n+1 D. n/2 ④: A. 长度 B. 深度 C. 栈顶D. 栈底 ⑤: A. 两个栈的栈顶同时到达栈空间的中心点. B. 其中一个栈的栈顶到达栈空间的中心点. C. 两个栈的栈顶在栈空间的某一位置相遇. D. 两个栈均不空,且一个栈的栈顶到达另一个栈的栈底. 3. 一个栈的输入序列为123…n,若输出序列的第一个元素是n,输出第i(1<=i<=n)个元素是()。 A. 不确定 B. n-i+1 C. i D. n-i 4. 若一个栈的输入序列为1,2,3,…,n,输出序列的第一个元素是i,则第j 个输出元素是()。 A. i-j-1 B. i-j C. j-i+1 D. 不确定的 5. 若已知一个栈的入栈序列是1,2,3,…,n,其输出序列为 p1,p2,p3,…,pN,若pN 是n,则pi 是( )。 A. i B. n-i C. n-i+1 D. 不确定 6. 有六个元素6,5,4,3,2,1 的顺序进栈,问下列哪一个不是合法的出栈序列?() A. 5 4 3 6 1 2 B. 4 5 3 1 2 6 C. 3 4 6 5 2 1 D. 2 3 4 1 5 6 7. 设栈的输入序列是1,2,3,4,则()不可能是其出栈序列。 A. 1,2,4,3, B. 2,1,3,4, C. 1,4,3,2, D. 4,3,1,2, E. 3,2,1,4, 8. 一个栈的输入序列为1 2 3 4 5,则下列序列中不可能是栈的输出序列的是()。 A. 2 3 4 1 5 B. 5 4 1 3 2 C. 2 3 1 4 5 D. 1 5 4 3 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 class arrQueue { public: arrQueue(intnSize=100); ~arrQueue(); arrQueue(constarrQueue& copyQueue); arrQueue&operator=(const arrQueue& otherQueue); voidinitializeQueue(); void destroyQueue(); bool isQueueEmpty(); bool isQueueFull(); void addQueue(constType& item); void deQueue(Type&deletedItem); private: int maxSize;

顺序队列的基本操作

#include #include #include #include #define QueueSize 50 typedef char QueueData; typedef struct queue { QueueData data[QueueSize]; int rear,front; }SeqQueue; void Menu() { printf("\n"); printf("|…………………………………………|\n"); printf("| 1、建立|\n"); printf("| |\n"); printf("| 2、显示|\n"); printf("| |\n"); printf("| 3、入队|\n"); printf("| |\n"); printf("| 4、出队|\n"); printf("| |\n"); printf("| 5、取队头元素|\n"); printf("| |\n"); printf("| 6、退出|\n"); printf("|…………………………………………|\n"); printf("\n"); printf("请选择菜单项,按回车键完成选择:"); } //模块1 建立 void Set(SeqQueue *&Q) { Q=(SeqQueue*)malloc(sizeof(SeqQueue)); if(Q==NULL) { printf("存储空间分配失败!\n"); exit(1); } else { printf("存储空间分配成功!\n"); } Q->front=Q->rear=-1; //置空队列

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

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

栈和队列_习题

第三章栈和队列 一、单项选择题 1.当利用大小为N的数组顺序存储一个栈时,假定用top=N表示栈空,则向这个栈入栈时,首先应执行( )语句修改top指针。 A. top++ B. top-- C. top=0 D. top=N-1 2.假定利用数组a[N]顺序存储一个栈,用top表示栈顶指针,top= -1表示栈空,并已知栈未满,当元素X入栈时执行的操作为( )。 A. a[--top]=X B. a[top--]=X C. a[++top]=X D. a[top++]=X 3.假定利用数组a[N]顺序存储一个栈,用top表示栈顶指针,top=-1表示栈空,并已知栈未空,当退栈并返回栈顶元素执行的操作为( )。 A. return a[--top] B. return a[top--] C. return a[++top] D. return a[top++] 4.假定一个链栈的栈顶指针用top表示,每个节点的结构为data域和next指针域,当p所指向的结点进栈时,执行的操作为() A. p->next=top;top=top->next B. top=p;p->next=top C. p->next=top->next D. p->next=top;top=p 5.假定一个链栈的栈顶指针用top表示,每个节点的结构为data域和next指针域,当执行退栈时,执行的操作为() A. top->next=top B. top=top->data C. top=top->next D. top->next=top->next->next 6.若让元素1,2,3,4依次进栈,则出栈次序不可能出现( )种情况。 A.3,2,1,4 B.2,1,4,3 C.4,3,2,1 D.1,4,2,3 7. 在一个循环队列中,队首指针指向队首元素的( )位置。 A. 前一个 B. 后一个 C. 当前 D. 最后 7. 在一个链队中,假设f与r分别为队首和队尾指针,则插入s所指结点的运算时( ) A.f->next=s;f=s B.r->next=s;r=s C.s->next=r;r=s D.s->next=f;f=s 8. 假定利用数组a[N]循环顺序存储一个队列,用f和r分别表示队首和队尾指针,并已知队未满,当元素X入队时执行的操作为( )。 A. a[++r%N]=X B. a[r++%N]=X C. a[--r%N]=X D. a[r--%N]=X 9. 假定利用数组a[N]循环顺序存储一个队列,用f和r分别表示队首和队尾指针,并已知队未空,当进行出队时执行的操作为( )。 A. return a[++r%N]=X B. return a[r++%N]=X C. return a[--r%N]=X D. return a[r--%N]=X 10. 判断一个队列QU(最多元素为MaxSize)为满队列的条件是( ) A. QU->rear-QU->front==MaxSize B. QU->rear-QU->front-1==MaxSize C. QU->rear==QU->front D. D.QU->front==QU->rear 11. 循环队列中是否可以插入下一个元素,( ) A. 与队头指针和队尾指针的值有关 B. 只与队尾指针的值有关,与队头指针的值无关 C. 只与数组大小有关,与队首指针和队尾指针的值无关 D.与曾经进行过多少次插入操作有关

栈和队列的基本操作讲解

《数据结构与算法》实验报告 专业班级姓名学号 实验项目 实验二栈和队列的基本操作。 实验目的 1、掌握栈的基本操作:初始化栈、判栈为空、出栈、入栈等运算。 2、掌握队列的基本操作:初始化队列、判队列为空、出队列、入队列等运算。 实验内容 题目1: 进制转换。利用栈的基本操作实现将任意一个十进制整数转化为R进制整数 算法提示: 1、定义栈的顺序存取结构 2、分别定义栈的基本操作(初始化栈、判栈为空、出栈、入栈等) 3、定义一个函数用来实现上面问题: 十进制整数X和R作为形参 初始化栈 只要X不为0重复做下列动作 将X%R入栈X=X/R 只要栈不为空重复做下列动作 栈顶出栈输出栈顶元素 题目2: 利用队列的方式实现杨辉三角的输出。 算法设计分析 (一)数据结构的定义 1、栈的应用 实现十进制到其他进制的转换,该计算过程是从低位到高位顺序产生R进制数的各个位数,而打印输出一般从高位到低位进行,恰好与计算过程相反。因此,运用栈先进后出的性质,即可完成进制转换。 栈抽象数据结构描述 typedef struct SqStack /*定义顺序栈*/ { int *base; /*栈底指针*/ int *top; /*栈顶指针*/ int stacksize; /*当前已分配存储空间*/ } SqStack; 2、队列的应用 由于是要打印一个数列,并且由于队列先进先出的性质,肯定要利用已经进队的元素在其出队之前完成杨辉三角的递归性。即,利用要出队的元素来不断地构造新的进队的元素,即在第N行出队的同时,来构造杨辉三角的第N+1行,从而实现打印杨辉三角的目的。

队列抽象数据结构描述 typedef struct SeqQueue { int data[MAXSIZE]; int front; /*队头指针*/ int rear; /*队尾指针*/ }SeqQueue; (二)总体设计 1、栈 (1)主函数:统筹调用各个函数以实现相应功能 int main() (2)空栈建立函数:对栈进行初始化。 int StackInit(SqStack *s) (3)判断栈空函数:对栈进行判断,若栈中有元素则返回1,若栈为空,则返回0。 int stackempty(SqStack *s) (4)入栈函数:将元素逐个输入栈中。 int Push(SqStack *s,int x) (5)出栈函数:若栈不空,则删除栈顶元素,并用x返回其值。 int Pop(SqStack *s,int x) (6)进制转换函数:将十进制数转换为R进制数 int conversion(SqStack *s) 2、队列 (1)主函数:统筹调用各个函数以实现相应功能 void main() (2)空队列建立函数:对队列进行初始化。 SeqQueue *InitQueue() (3)返回队头函数:判断队是否为空,若不为空则返回队头元素。 int QueueEmpty(SeqQueue *q) (4)入队函数:将元素逐个输入队列中。 void EnQueue(SeqQueue *q,int x) (5)出队函数:若队列不空,则删除队列元素,并用x返回其值。 int DeQueue(SeqQueue *q) (6)计算队长函数:计算队列的长度。 int QueueEmpty(SeqQueue *q) (7)输出杨辉三角函数:按一定格式输出杨辉三角。 void YangHui(int n) (三)各函数的详细设计: 1、栈 (1)int main()主函数 定义s为栈类型 调用函数建立空栈

相关文档
最新文档