您的位置：360文档中心› 数据结构堆栈与队列实验报告

数据结构堆栈与队列实验报告

合集下载

数据结构栈和队列的基本操作及应用实验报告

数据结构栈和队列的基本操作及应用实验报告

实验日期2010.4.26教师签字________________ 成绩__________【实验名称】第三章栈和队列的基本操作及应用【实验目的】（1）熟悉栈的特点（先进后出）及栈的基本操作，如入栈、出栈等，掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现；（2）熟悉队列的特点（先进先出）及队列的基本操作，如入队、出队等，掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。

【实验内容】1.链栈的基本操作（链栈的初始化、进栈、出栈以及取栈顶的值)#include H stdio.h H#include H malloc.h ninclude "stdlib.h"typedef int Elemtype;typedef struct stacknode {Elemtype data;stacknode * next;JStackNode;typedef struct {stacknode * top; 〃栈顶指针} LinkStack;/*初始化链栈*/void InitStack(LinkStack * s){ s->top=NULL;printf("\n已经初始化链栈！\n”)；)/*链栈置空*/void setEnipty(LinkStack * s){ s・>top 二NULL;printf(H\n 链栈被置空! \n”)；}/*入栈*/void pushLstack(LinkStack * s, Elemtype x){ StackNode * p; p=(StackNode *)maHoc(sizeof(StackNode)); 〃建立一个节点° p->data=x;p->next=s->top; //ill于是在栈顶pushLstack,所以要指向栈顶。

s->top=p; 〃插入}/*出栈勺Elemtype popLstack(LinkStack * s){ Elemtype x;StackNode * p; p=s->top; 〃指向栈顶if (s->top ==0){ printf("\n栈空，不能出栈！\n”)； exit(-l);}x=p->data;s->top=p->next; 〃当前的栈顶指向原栈的nextfree(p); 〃释放return x;}/*取栈顶元素*/Elemtype StackTop(LinkStack *s){ if (s->top ==0){ printf(H\n 链栈空\n”)；exit(-l);)return s->top->data;}/*遍历链栈*/void Disp(LinkStack * s){ printf("\n链栈中的数据为：\n");printf(H======================================\n n); StackNode * p;p=s->top;while (p!=NULL){ printf(H%d\n'\p->data);p=p->next;} printf("=======================================\n");}void main(){ printf(H====================链栈操作==========\n\nj;int i,m,n,a; LinkStack * s; s=(LinkStack *)malloc(sizeof(LinkStack)); int cord;do{ printf(H\n n);printf(”第一次使用必须初始化! \n H);printf(H\ii 主菜单W);printf(H\n 1 初始化链栈\n“);printf(H\n 2 入栈\n“);printf(M\ii 3 出栈\n")；printf(H\n 4 取栈顶元素\n")；printf(H\n 5 置空链栈\n")；printf(H\n 6 结束程序运行\n”);printf(H\n ---------------------------------printfC*请输入您的选择(1,2, 3, 4, 5,6)”)；scanf(M%d,\&cord);printf(H\n n);switch(cord){ case 1:{ InitStack(s);Disp(s);} break;case 2:(printfC输入将要压入链栈的数据的个数：I匸“)；scanf(”％d”,&n);printf(”依次将％d个数据圧入链栈：\n",n);for(i=l;i<=n;i++){scanf("%d”,&a); pushLstack(s,a);}Disp ⑸；[break;case 3:{ printf("\n出栈操作开始!\n“)； printf("输入将要出栈的数据个数：m=”)；scrmf(”％d：&m);for(i=I;i<=m;i++){printf("\n 第％d 次出栈的数据是：%d",i,popLstack(s));)Disp(s);[break;case 4:{ printf("\n\n 链栈的栈顶元素为：%d\n",StackTop(s)); printf(H\n H);(break;case 5:{ setEnipty(s);Disp(s);(break;case 6:exit(O);})while (cord<=6);}2.顺序栈的基本操作(顺序栈的初始化、进栈、出栈以及取栈顶的值) #include<stdio.h>#include<malloc.h>#include<stdlib.h>#define STACKSIZE 100#define STACKINCREMENT 10#define null 0typedef struct {int 水base;int *top;int stacksize;}SqStack;SqStack Initstack(){SqStack S;S.base=(int *)malloc(STACKSIZE*sizeof(int));if(!S.base){printf("\n 存储分配失败\n");exit(0);}S.top=S.base;S.stacksize 二STACKSIZE;return S;}int StackEmpty(SqStack S){if(S.top==S.base) return 1;else return 0;}int StackLength(SqStack S){int *p;p=S.base;for(int i=0;p!=S・top;p++,i++);return i;int GetTop(SqStack S)int e;if(StackEmpty(S)) {printf(”当前栈为空,不能执行此操作\n”);exit(O);}e=*(S.top-l);return e;}int Push(SqStack &Sjnt e){if(StackLength(S)>=S.stacksize) {S.base=(int*)realloc(S.base,(STACKSIZE+STACKINCREMENT)*sizeof(int));if(!S.base){printf("\n 再分配存储失败\n");return 0;}S ・ top=S ・ base+S. stacksize;S.stacksize+二STACKINCREMENT;}*S.top++=e;return 1;}int Pop(SqStack &S){int e;if(StackEmpty(S)){printf("当前栈为空,不能执行此操作\n”);exit(0);}e=*—S.top;return e;}void main(){int i=0,e;int *p;SqStack S;S=Initstack();printf("\n 1.元素进栈\n 2.元素出栈\n 3.取栈顶元素\n 4. 求栈的长度\n 5.判栈空\n 6.退出\n“)；for(;i!=6;){printf(“\n请选择你要进行的操作：“)；scanf(H%d\&i);switch(i){case l:printf("\n请输入进栈元素：")；scanf(”％cT,&e);Push(S,e);p=S.base;printf("\n当前栈中元素："); if(StackEmpty(S))printfC'当前栈为空\n”); while(p!=S.top){printf(n%d '\*p);p++;}break;case 2:printf("\n%d 已出栈\n",Pop(S)); printf("\n当前栈中元素：”)；if(StackEmpty(S))printf(,'当前栈为空\n“);p=S.base;while(p !=S .top) {printf(" %d ",*p);p++;} break;case 3:printf("\n 栈顶元素为:%d\n",GetTop(S));break;case 4:printf("\n 栈的长度为:%d\n",StackLength(S));break;case 5:if(StackEmpty(S))printf("\n 当前栈为空\n");else printf("\n 当前栈不空\n"); break;default:printf("\n 退出程序\n");}}}3•顺序队列的基本操作(顺序队的初始化、进队、出对以及取对头)#include <stdio.h>#include <malloc.h>#define MAXNUM 100#define Elemtype int#define TRUE 1#define FALSE 0typedef struct{ Elemtype queuefMAXNUM];int front;int rear;Jsqqueue;/*队列初始化*/int initQueue(sqqueue *q){ if(!q) return FALSE;q->front=-1;q->rear=-1;return TRUE;}/*入队*/int append(sqqueue Elemtype x){ if(q->rear>=MAXNUM-1) return FALSE;q->rear++;q->queue[q->rear]=x;return TRUE;/*出队*/Elemtype Delete(sqqueue *q){ Elemtype x;if (q->front==q->rear) return 0;x=q->queue[++q->front];return x;}/*判断队列是否为空*/int Empty(sqqueue *q){ if (q->front=q->rear) return TRUE;return FALSE;}/*取队头元素*/int gethead(sqqueue *q){ if (q->front==q->rear) return 0; return(q->queue[q->front+1]);)/*遍历队列*/void display(sqqueue *q){ int s;s=q->front;if (q->front==q->rear) printf(”队列空!\n“)；else{printf("\n顺序队列依次为：“)；while(s<q->rear){s=s+l;printf(H%d<-'\ q->queue[s]);}printf(H\n H);printf("顺序队列的队尾元素所在位置:rear=%d\n",q->rear); printf("顺序队列的队头元素所在位S: front=%d\n " ,q->front);})/*建立顺序队列*/void Setsqqueue(sqqueue *q){ int njjn;printf("\n请输入将要入顺序队列的长度:”)；scanf(H%d,r,&n);printfC*\n请依次输入入顺序队列的元素值:\n“)；for (i=0;i<n;i++){ scanf(”％d”,&m);append(qjn);}main(){ sqqueue *head;int x,y,z,select; head=(sqqueue*)malloc(sizeof(sqqueue));do{printf("\n第一次使用请初始化！\n");printf("\n 请选择操作(1 -7):\n”)；pri ntf("=================================\n"); printf(n l 初始化\n“)；printf("2建立顺序队列\n");printf("3 入队\n”);printf("4 出队\n“)；printf("5判断队列是否为空\n“)；printf("6取队头元素\n");printf(H7 遍历队列\n“)；printf(,,===================================\n");scanf("%d",&select);switch(select){case 1:{ initQueue(head);printfC'B经初始化顺序队列! \n“)； break;)case 2:{ Setsqqueue(head);printf("\n已经建立队列！\n");display(head); break;)case 3:{ printf("请输入队的值:\n”)；scanf(”％cT,&x);append(head,x)； display(head);break;)case 4:{ z=Delete(head);printf("\n队头元素％(1已经出队！\n",z); display(head);break;)case 5:if(Empty(head))printf(”队列空\n”)；elseprintf("队列非空\n“)；break;}case 6:{ y=gethead (head);printf("队头元素为:%d\n",y);break;)case 7:{ display(head);break;}}}while(select<=7);}4•链队列的基本操作(链队列的初始化、进队、出对操作)#include<stdio.h>#include<stdlib.h>#define ElemType inttypedef struct Qnode{ ElemType data;struct Qnode *next;(Qnodetype;typedef struct{ Qnodetype *front;Qnodetype *rear;JLqueue;/*初始化并建立链队列*/void creat(Lqueue *q){ Qnodetype *h;int i,n,x;printf(”输入将建立链队列元素的个数：n=”);scanf(“％d",&n);h=(Qnodetype*)malloc(sizeof(Qnodetype));h->next=NULL;q->front=h;q->rear=h;for(i=l;i<=n;i++){ printfC链队列第％<1个元素的值为：”,i);scanf(“％d”,&x);Lappend(q,x);)/*入链队列*/void Lappend(Lqueue *q,int x){ Qnodetype *s; s=(Qnodetype*)manoc(sizeof(Qnodetype)); s->data=x;s->next=NULL;q->rear->next=s;q->rear=s;}/*出链队列勺ElemType Ldelete(Lqueue *q){ Qnodetype *p;ElemType x;if(q->front==q->rear){ printfC* 队列为空!\n“);x=0;)else{ p=q->front->next;q->front->next=p->next; if(p->next=NULL) q->reai*=q->front;x=p->data;free(p);}return(x);)/*遍历链队列*/void display(Lqueue *q){ Qnodetype *p;p=q->front->next; /*指向第一个数据元素节点*/printf("\n链队列元素依次为：”);while(p!=NULL){ printf("%d—>",p->data);p=p->next;}printf(H\n\n遍历链队列结束！\n n);}main(){ Lqueue *p;int x^cord;printf(H\n*****第一次操作请选择初始化并建立链队列！ **林*\口”);W)； switch(cord){ case 1:{ p=(Lqueue *)malloc(sizeof(Lqueue)); creat(p);display(p);} break;case 2:{ printf (“请输入队列元素的值：x=“);scanf(”％d”,&x);Lappend(p,x); display(p);(break;case 3:{ printf(n 出链队列元素:x=%d\ii*\Ldelete(p));display(p);(break;case 4:{display(p);) break;case 5:{exit (0);) }(while (cord<=5);) 5 •循环队列的基本操作:#include<stdio.h> #include<iostream.h> #include<malloc.h> #define maxsize 100 struct Queueint *base; int front; int rear;)；void initQueue(Queue &Q){Q.base=(int *)malloc(maxsize*sizeof(int));Q.front=Q.rear=0; printf(M 1初始化并建立链队列 \n n ); printf (” 2入链队列 S'); printf (” 3 出链队列 S');printf(H 4 遍历链队列W); printf(H 5 结束程序运行W); 主菜单 W)； printf(H =======================================\n H );printf(Hscanf(M %d 1',&cord);do { printf(H \n链队列的基本操作\n J ； printf(H = printf(n W)；}int QueueLen(Queue Q){return(Q.rear- Q・ front+maxsize)%maxsize;}void EnQueue(Queue &Q,int e){if((Q.rear+1 )%maxsize=Q.front)cout«"队列已满，无法插入!"«endl;else{Q.base[Q.rear]=e; Q.reai-(Q.rear+ l)%maxsize;)}int DeQueue(Queue &Q,int &e){if(Q.reai"==Q.front) coutvv"队列已空，无法删除「vvendl; else{e=Q.base[Q.front]; Q.front=(Q.front+1 )%maxsize;cout«"被删除的元素是:,,<<'\t'«e«endl;return e;})void main(){Queue Q;initQueue(Q);loop:cout«、Fvv"请选择你要进行的操作:"«endl;cout«'\t'«" 1 .插入元素"<<endl«'\t'«,'2.删除元素"<<endl«,\t'«"3.求队列长度,,<<endl«,\t,«,,4.结束u«endl;int i; cin»i;switch(i){case(l):{int e;coutvv”请输入要插入的元素: cin»e;EnQueue(Q,e);goto loop;}case(2):{int e;DeQueue(Q.e);goto loop;}case(3):{int 1;l=QueueLen(Q);cout«"队列的长度为:"«'\t'«l«endl; goto loop;)case(4): break;default:cout«"输入错误，请重新输入!"«endl;goto loop;}}6 •两个栈实现队列的功能#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<iostream.h>#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef char SElemType;typedef struct{SEIeniType *base;SEleniType *top;int stacksize;JSqStack;〃队列III两个栈S1.S2构成typedef struct{SqStack S1;SqStack S2;}Queue;void InitStack(SqStack *S)S->base=(SElemType *)malloc(STACKJNIT_SIZE*sizeof(SElemType)); if(!S->base) exit(O);S->top=S->base; S->stacksize=STACK_INIT_SIZE;}void push(SqStack *S,SElemType e){if(S->top-S->base==S->stacksize){S・> base=(SElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S->base) exit(O);S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*(S->top)++=e;}void pop(SqStack *S,SElemType *e){if(S->top==S->base) exit(O);S->top—; *e=*(S->top);}〃队列的相关操作void InitQueue(Queue *Q){InitStack(&(Q->S 1 ));InitStack(&(Q->S2));}void EnQueue(Queue *Q,SElemType e){push(&(Q->S l),e);)void DeQueue(Queue *Q,SElemType *e){if((Q->S2). top==(Q->S2). base){while((Q->S 1 ).top!=(Q->S 1 ).base) {pop(&(Q->S 1 ),e);push(&(Q->S2),*e);} pop(&(Q->S2),e);}else pop(&(Q->S2),e);}int QueueEmpty(Queue Q)if(Q.S 1 .base==Q.S 1 .top&&Q・S2・bjse==Q・S2・top) return 0; else return 1; void main(){SEIemType e; Queue Q; int i;InitQueue(&Q);for(i=0;i< 10:i++) EnQueue(&Q/a,+i); while(QueueEmpty(Q)!=O){DeQueue(&Q,&e); cout«e;}cout«endl;}7・用双端队列模拟栈#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define null 0typedef struct QNode{int data;struct QNode *next;struct QNode *prior;)QNode;typedef struct)QNode *frontL*front2;QNode *rearl,*rear2;}LinkDeque;LinkDeque InitQueue(){LinkDeque Q;Q.front 1 =Q.rearl =(QNode *)malloc(sizeof(QNode)); if(!Q.front 1){printf("\n 存储分配失败\n");exit(O);} Q.front2=Q.rear2=(QNode *)malloc⑸zeof(QNode));if(!Q.front2){printf("\n 存储分配失败\n H);exit(O);) Q. front l->next=Q.front2;Q.front2->next=Q.frontl;return Q;}int EnDeque(LinkDeque &Q,int e){QNode *p;p=(QNode *)malloc(sizeof(QNode)); if(!p){printf("\n 存储分配失败\n");exit(O);} p->data=e;p->next=Q.front2;p->prior=Q.rearl;Q.rearl->next=p;Q.reail 二p;Q.rear2=Q.front 1 ->next;return 1;}int DeDeque(LinkDeque &Q){int e;QNode *p;if(Q.front 1 ==Q.rear 1){printf("栈为空,不能执行删除操作\n");return 0;)p=Q.rearl;e=p->data;p->prior->next=p->next;p->next->prior=p->prior;Q.rearl=p->prior;if(Q.front l==Q.front2){Q.rear 1=Q.front l;Q.rear2=Q.front2;} free(p);return e;}int DequeLength(LinkDeque Q){int len=0;QNode *p;p=Q.frontl->next;while(p!=Q.front2){ Ien++;p=p->next;)return len;}int Gethead(LinkDeque Q){QNode *p;if(Q.front 1 !=Q.rear 1){p=Q.rear 1 ;return p->data;}}void main(){int i=0,e;LinkDeque Q;QNode *p;Q=InitQueue();printf(n\n 1.元素进栈\n 2.元素出栈\n 3.求栈的长度\n 4. 取栈顶元素\n 5.退出\n");for(:i!=5;){printf(-\n请选择你要进行的操作：”)；scanf(n%d\&i);switch(i){case l:printf("\n请输入进栈元素：”)；scanf(”％cT，&e);EnDeque(Q,e);if(Q.front 1 !=Q.rearl){printf("\n 当前栈元素:");p=Q.front 1 ->next;while(p!=Q.front2){ printf(H%d '\p->data);p=p->next;}}else printf(n当前栈为空\iT);break;case 2:if(Q.frontl!=Q.rearl)printf(H\n 已删除%d\n*\DeDeque(Q));eIse printfC*栈为空，不能此删除操作\n“)；if(Q.frontl !=Q.rearl)(printf("\n 当前栈元素:");p=Q.frontl・>next;while(p!=Q.front2){ printf(H%d H,p->data);p=p->next;}}else printfC当前栈为空E)；break;case 3:printf(M\n 栈的长度：%d,\DequeLength(Q));break;case 4:if(Q.front 1 !=Q.rearl)printf(H\n 栈顶元素:%d\n”,Gethead(Q));else printfC栈为空，不能此删除操作\n H);break;default:printf("\n 结束程序\n");}1}&约瑟夫队列：#include<stdio.h>#include<malloc.h>#include<iostream.h>#define len sizeof(struct QNode)struct QNode{int data;QNode *next;};void main(){int m,n,k,i,e,num=l;cout«"请输入总人数:"«endl; cin»n;cout«"请输入出局数:"«endl; cin»m;coutvv"请输入开始报数人的编号:"«endl; cin»k;QNodeQ=(QNode *)malloc(len);Q->next=Q;Q->data= 1; p二Q;for(i=2;i<=n;i++){p->next=(QNode *)malloc(len);p=p->next;p->data=i;)p->next=Q;r=Q;t=r;for(i= 1 ;i<=k-1 ;i++){ t=r;r=r->next;}cout«"出队顺序为:"vvendl;do{for(i= 1 ;i<=m-1 ；i++){ t=r;r=r->next;)e=r->data;t->next=r->next;r=t->next;cout«e«H H; num++;}while(num<=n);cout«endl;)【小结讨论】1.一个程序中如果要用到两个栈时，可通过两个栈共享一维数组来实现，即双向栈共享邻接空间。

算法与数据结构栈与队列实验报告

算法与数据结构栈与队列实验报告

实验二 栈和队列实现四则运算一、实验目的及要求：1、掌握栈和队列的基本操作：建立、插入、删除、查找、合并2、掌握用栈和队列的储存3、熟悉C 语言上机编程环境4、掌握编译、调试程序的方法二、实验内容：采用栈进行表达式的求值，表达式求值是程序设计语言编译中的一个最基本问题。

它的实现是栈应用的又一个典型例子，本报告使用的是“算符优先法”求表达式的值。

要把一个表达式翻译成正确求值的一个机器指令序列，或者直接对表达式求值，首先要能够正确解释表达式。

若要正确翻译则首先要了解算术四则运算的规则。

即：（1）、先乘除，后加减； （2）、从左算到右； （3）、先括号内后括号外。

任何一个表达式都是由操作数、运算符和界限符组成的，我们称它们为单词。

一般地，操作数既可以是常数也可以是被说明为变量或常量的标识符；运算符可以分为算术运算符、关系运算符和逻辑运算符3类；基本界限符有左右括号和表达式结束符等。

为了叙述的简洁，我们仅讨论简单算术表达式的求值问题。

这种表达式只包含加、减、乘、除4种运算符。

我们把运算符和界限符统称为算符，它们构成的集合命名为OP 。

根据上述3条运算规则，在运算的每一步中，任意两个相继出现的算符1θ和2θ之间的优先级之多是以下3种关系之一：12θθ< 1θ的优先级低于2θ 12θθ= 1θ的优先级等于2θ 12θθ> 1θ的优先级高于2θ根据实际情况推导出如下的优先关系算符间的优先关系表有规则（3），+、-、*和/为1θ时优先性均低于“（”但高于“），”由规则（2），当12θθ=时，令12θθ>，“#”是表达式的结束符。

为了算法简洁，在表达式左右括号的最左边也虚设了一个“#”构成整个表达式的一对括号。

表中的“（”=“）”表示当左右括号相遇时，括号内的运算已经完成。

同理，“#”=“#”表示整个表达式求值完毕。

“）”与“（、“#”与“）”以及“（”与“#”之间无优先级，这是因为表达式中不允许它们相继出现，一旦遇到这种情况，则可以认为出现语法错误。

数据结构实验报告_实验报告_

数据结构实验报告_实验报告_

数据结构实验报告想必学计算机专业的同学都知道数据结构是一门比较重要的课程，那么，下面是小编给大家整理收集的数据结构实验报告，供大家阅读参考。

数据结构实验报告1一、实验目的及要求1)掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们。

本实验训练的要点是“栈”和“队列”的观点;二、实验内容1) 利用栈，实现数制转换。

2) 利用栈，实现任一个表达式中的语法检查(选做)。

3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);三、实验流程、操作步骤或核心代码、算法片段顺序栈：Status InitStack(SqStack &S){S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status DestoryStack(SqStack &S){free(S.base);return OK;}Status ClearStack(SqStack &S){S.top=S.base;return OK;}Status StackEmpty(SqStack S){if(S.base==S.top)return OK;return ERROR;}int StackLength(SqStack S){return S.top-S.base;}Status GetTop(SqStack S,ElemType &e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;Status Push(SqStack &S,ElemType e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackTraverse(SqStack S){ElemType *p;p=(ElemType *)malloc(sizeof(ElemType));if(!p) return ERROR;p=S.top;while(p!=S.base)//S.top上面一个...p--;printf("%d ",*p);}return OK;}Status Compare(SqStack &S){int flag,TURE=OK,FALSE=ERROR; ElemType e,x;InitStack(S);flag=OK;printf("请输入要进栈或出栈的元素："); while((x= getchar)!='#'&&flag) {switch (x){case '(':case '[':case '{':if(Push(S,x)==OK)printf("括号匹配成功!\n\n"); break;case ')':if(Pop(S,e)==ERROR || e!='('){printf("没有满足条件\n");flag=FALSE;}break;case ']':if ( Pop(S,e)==ERROR || e!='[')flag=FALSE;break;case '}':if ( Pop(S,e)==ERROR || e!='{')flag=FALSE;break;}}if (flag && x=='#' && StackEmpty(S)) return OK;elsereturn ERROR;}链队列：Status InitQueue(LinkQueue &Q) {Q.front =Q.rear=(QueuePtr)malloc(sizeof(QNode));if (!Q.front) return ERROR;Q.front->next = NULL;return OK;}Status DestoryQueue(LinkQueue &Q) {while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}Status QueueEmpty(LinkQueue &Q){if(Q.front->next==NULL)return OK;return ERROR;}Status QueueLength(LinkQueue Q){int i=0;QueuePtr p,q;p=Q.front;while(p->next){i++;p=Q.front;q=p->next;p=q;}return i;}Status GetHead(LinkQueue Q,ElemType &e) {QueuePtr p;p=Q.front->next;if(!p)return ERROR;e=p->data;return e;}Status ClearQueue(LinkQueue &Q){QueuePtr p;while(Q.front->next ){p=Q.front->next;free(Q.front);Q.front=p;}Q.front->next=NULL;Q.rear->next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e) {QueuePtr p;p=(QueuePtr)malloc(sizeof (QNode));if(!p)return ERROR;p->data=e;p->next=NULL;Q.rear->next = p;Q.rear=p; //p->next 为空return OK;}Status DeQueue(LinkQueue &Q,ElemType &e) {QueuePtr p;if (Q.front == Q.rear)return ERROR;p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p)Q.rear = Q.front; //只有一个元素时(不存在指向尾指针) free (p);return OK;}Status QueueTraverse(LinkQueue Q){QueuePtr p,q;if( QueueEmpty(Q)==OK){printf("这是一个空队列!\n");return ERROR;}p=Q.front->next;while(p){q=p;printf("%d<-\n",q->data);q=p->next;p=q;}return OK;}循环队列：Status InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base)exit(OWERFLOW);Q.front=Q.rear=0;return OK;}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];Q.front=(Q.front+1)%MAXQSIZE;return OK;}int QueueLength(SqQueue Q){return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;}Status DestoryQueue(SqQueue &Q){free(Q.base);return OK;}Status QueueEmpty(SqQueue Q) //判空{if(Q.front ==Q.rear)return OK;return ERROR;}Status QueueTraverse(SqQueue Q){if(Q.front==Q.rear)printf("这是一个空队列!");while(Q.front%MAXQSIZE!=Q.rear){printf("%d<- ",Q.base[Q.front]);Q.front++;}return OK;}数据结构实验报告2一.实验内容：实现哈夫曼编码的生成算法。

数据结构栈与队列的实验报告

数据结构栈与队列的实验报告

数据结构栈与队列的实验报告实验概述本次实验的目的是通过对栈和队列进行实现和应用，加深对数据结构中的栈和队列的理解和巩固操作技能。

栈和队列作为常见的数据结构在程序开发中得到了广泛的应用，本次实验通过 C++ 语言编写程序，实现了栈和队列的基本操作，并对两种数据结构进行了应用。

实验内容1. 栈的实现栈是一种先进后出的数据结构，具有后进先出的特点。

通过使用数组来实现栈，实现入栈、出栈、输出栈顶元素和清空栈等操作。

对于入栈操作，将元素插入到数组的栈顶位置；对于出栈操作，先将数组的栈顶元素弹出，再使其下移，即将后面的元素全部向上移动一个位置；输出栈顶元素则直接输出数组的栈顶元素；清空栈则将栈中所有元素全部清除即可。

3. 栈和队列的应用利用栈和队列实现八皇后问题的求解。

八皇后问题，是指在8×8 的国际象棋盘上放置八个皇后，使得任意两个皇后都不能在同一行、同一列或者同一对角线上。

通过使用栈来保存当前八皇后的位置，逐个放置皇后并检查是否有冲突。

如果当前位置符合要求，则将位置保存到栈中，并继续查询下一个皇后的位置。

通过使用队列来进行八数码问题的求解。

八数码问题，是指在3×3 的矩阵中给出 1 至 8 的数字和一个空格，通过移动数字，最终将其变为 1 2 3 4 5 6 7 8 空的排列。

通过使用队列，从初始状态出发，枚举每种情况，利用队列进行广度遍历，逐一枚举状态转移，找到对应的状态后进行更新，周而复始直到找到正确的答案。

实验结果通过使用 C++ 语言编写程序，实现了栈和队列的基本操作，并对八皇后和八数码问题进行了求解。

程序执行结果如下：栈和队列实现的基本操作都能够正常进行，并且运行效率较高。

栈和队列的实现方便了程序编写并加速了程序运行。

2. 八皇后问题的求解通过使用栈来求解八皇后问题，可以得到一组成立的解集。

图中展示了求解某一种八皇后问题的过程。

从左到右是棋盘的列数，从上到下是棋盘的行数，通过栈的操作，求出了在棋盘上符合不同要求（不在同一行、同一列和斜线上）的八皇后位置。

国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案

国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案
{
x=Pop(s); /*出栈*/
printf("%d ",x);
InQueue(sq,x); /*入队*/
}
printf("\n");
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
ElemType Pop(SeqStack *s); /*出栈*/
ElemType GetTop(SeqStack *s); /*取栈顶元素*/
void DispStack(SeqStack *s); /*依次输出从栈顶到栈底的元素*/
void DispBottom(SeqStack *s); /*输出栈底元素*/
} SeqQueue; /*定义顺序队列*/
void InitStack(SeqStack *s); /*初始化栈*/
int StackEmpty(SeqStack *s); /*判栈空*/
int StackFull(SeqStack *s); /*判栈满*/
void Push(SeqStack *s,ElemType x); /*进栈*/
sq=(SeqQueue *)malloc(sizeof(SeqQueue));
InitQueue(sq);
printf("(8)队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
printf("(9)出栈/入队的元素依次为:");

数据结构实验报告之栈和队列

数据结构实验报告之栈和队列

数据结构实验报告之栈和队列1. 编写程序实现顺序栈的各种基本运算：初始化、销毁、清空、判断是否为空栈、求栈的长度、取栈顶元素、进栈、出栈。

在此基础上设计⼀个主程序完成如下功能：（1）初始化栈s；（2）判断栈s是否为空；（3）依次进栈元素a，b，c，d；（4）判断栈s是否为空；（5）输出栈s的长度；（6）栈⾥元素依次出栈,并输出；（7）销毁栈s。

#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef char SElemType;#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef struct {SElemType *base; //栈底指针SElemType *top; //栈顶指针int stacksize; //当前已分配的存储空间} SqStack;Status InitStack(SqStack &S) { //构造⼀个空栈SS.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//InitStackStatus StackLength(SqStack S) {return S.top - S.base;}//StackLengthStatus DestoryStack(SqStack &S) {S.top = S.base;free(S.base);//若base的值为NULL，则表明栈结构不存在S.base = NULL;S.top = NULL;S.stacksize = 0;return OK;}Status StackEmpty(SqStack S) {if (S.top == S.base)return1;elsereturn0;}//StackEmptyStatus GetTop(SqStack S, SElemType &e) {if (S.top == S.base) return ERROR;e = *(S.top - 1);return OK;}//GetTopStatus Push(SqStack &S, SElemType e) {if (S.top - S.base >= S.stacksize) {S.base = (SElemType*)realloc(S.base,(S.stacksize + STACKINCREMENT) * sizeof(SElemType));if (!S.base)exit(OVERFLOW);S.top = S.base + S.stacksize;S.stacksize+= STACKINCREMENT;}*S.top++=e;return OK;}//PushStatus Pop(SqStack &S, SElemType &e) {//判断栈是否为空if (S.base == S.top)return ERROR;e = *(S.top - 1);S.top--;return OK;}//Popvoid main(){SqStack s;SElemType e;printf("(1)初始化栈\n");InitStack(s);printf("(2)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(3)依次进栈元素a，b，c，d\n");Push(s, 'a');Push(s, 'b');Push(s, 'c');Push(s, 'd');printf("(4)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(5)The length of the stack is %d\n", StackLength(s));printf("(6)The stack is ");while (!StackEmpty(s)){Pop(s, e);printf("%c \n", e);}printf("(7)销毁栈s");DestoryStack(s);}运⾏结果：2. 编写程序实现链队列的各种基本运算：初始化、销毁、清空、判断是否为空队列、求队列的长度、取队列的头元素、⼊队、出队。

湘潭大学数据结构实验3实验报告源代码栈和队列剖析

“数据结构和算法II”课程实验报告实验名称：栈和队列的综合应用班级姓名学号实验日期：实验机时：2 学时实验成绩：-------------------------------------------------------------------------------一.实验目的：1.熟悉栈的定义和基本操作2.熟悉队列的定义和基本操作3.掌握递归和非递归算法的实现技术和实际应用4.加深对栈结构的理解，培养解决实际问题的编程能力。

二.实验内容：（1）基本实验内容：实现Hanoi 塔的问题；完成迷宫问题或马踏棋盘问题求解。

三.程序及注释：1.Hanoi塔问题：typedef int ElementType;#ifndef _Stack_h#define _Stack_hstruct Node;typedef struct Node *PtrToNode;typedef PtrToNode Stack;int IsEmpty( Stack S );Stack CreateStack( void );void DisposeStack( Stack S );void MakeEmpty( Stack S );void Push( ElementType X, Stack S );ElementType Top( Stack S );void Pop( Stack S );#endif#include <stdio.h>#include <stdlib.h>#define Error( Str ) FatalError( Str )#define FatalError( Str ) fprintf( stderr, "%s\n", Str ), exit( 1 ) #include <stdlib.h>struct Node//定义栈的结构{ElementType Element;PtrToNode Next;char bianhao;};int IsEmpty( Stack S )//判断栈是否为空{return S->Next == NULL;}Stack CreateStack()//创建一个空栈{Stack S;S = malloc( sizeof( struct Node ) );if( S == NULL )FatalError( "Out of space!!!" );S->Next = NULL;MakeEmpty( S );return S;}void MakeEmpty( Stack S )//将栈置空{if( S == NULL )Error( "Must use CreateStack first" );elsewhile( !IsEmpty( S ) )Pop( S );}Void DisposeStack( Stack S )//销毁栈{MakeEmpty( S );free( S );}void Push( ElementType X, Stack S )//向栈S中插入元素n{PtrToNode TmpCell;TmpCell = malloc( sizeof( struct Node ) );if( TmpCell == NULL )FatalError( "Out of space!!!" );else{TmpCell->Element = X;TmpCell->Next = S->Next;S->Next = TmpCell;}}Void Pop( Stack S )//推出栈顶元素{PtrToNode FirstCell;if( IsEmpty( S ) )Error( "Empty stack" );else{FirstCell = S->Next;S->Next = S->Next->Next;free( FirstCell );}}void Move(Stack x,int n,Stack z)//将第编号为n的圆盘从x移动到z{Pop(x);Push(n,z);printf("%2d:将原盘 %d 从 %c 移动到 %c\n",++c,n,x->bianhao,z->bianhao);} void hanoi(int n,Stack x,Stack y,Stack z)//汉诺塔问题解决函数{if (n==1)Move(x,1,z);else{hanoi(n-1,x,z,y);//将编号为1到n-1的圆盘从x利用z移动到yMove(x,n,z);//将编号为n的圆盘从x移动到zhanoi(n-1,y,x,z);}}// 将编号为1到n-1的圆盘从y利用x移动到zint main(){int n,i;Stack x=CreateStack();x->bianhao='x';//对栈x进行编号Stack y=CreateStack();y->bianhao='y';//对栈y进行编号Stack z=CreateStack();z->bianhao='z';//对栈z进行编号printf("请输入Hanoi塔的高度\n");scanf("%d",&n);for(i=n;i>0;i--)Push(i,x);hanoi(n,x,y,z);printf("移动完成！！！");DisposeStack(x);//销毁栈xDisposeStack(y);//销毁栈yDisposeStack(z);//销毁栈z}2.马踏棋盘typedef int ElementType;#ifndef _Stack_h#define _Stack_hstruct Node;typedef struct Node *PtrToNode;typedef PtrToNode Stack;int IsEmpty( Stack S );Stack CreateStack( void );void DisposeStack( Stack S );void MakeEmpty( Stack S );void Push( ElementType X, Stack S );ElementType Top( Stack S );void Pop( Stack S );#include <stdio.h>#include <stdlib.h>#define Error( Str ) FatalError( Str )#define FatalError( Str ) fprintf( stderr, "%s\n", Str ), exit( 1 ) #include <stdlib.h>struct Node//定义栈的结构{ElementType Element;PtrToNode Next;};int IsEmpty( Stack S )//判断栈是否为空{return S->Next == NULL;}Stack CreateStack()//创建一个栈{Stack S;S = malloc( sizeof( struct Node ) );if( S == NULL )FatalError( "Out of space!!!" );S->Next = NULL;MakeEmpty( S );return S;}void MakeEmpty( Stack S )//将栈制空{if( S == NULL )Error( "Must use CreateStack first" );elsewhile( !IsEmpty( S ) )Pop( S );}void DisposeStack( Stack S )//销毁栈{MakeEmpty( S );free( S );}void Push( ElementType X, Stack S )//向栈内输入一个值{PtrToNode TmpCell;TmpCell = malloc( sizeof( struct Node ) );if( TmpCell == NULL )FatalError( "Out of space!!!" );else{TmpCell->Element = X;TmpCell->Next = S->Next;S->Next = TmpCell;}}int e;//用来暂时储存从栈里pop出的元素void Pop( Stack S )//输出栈顶的元素{PtrToNode FirstCell;if( IsEmpty( S ) )Error( "Empty stack" );else{e=S->Next->Element;FirstCell = S->Next;S->Next = S->Next->Next;free( FirstCell );}}void solve(int a,int b,Stack x,Stack y)//棋盘问题函数{int qipan[9][9]={0};qipan[a][b]=1;int i,m,n,step[10][3]={{0,0,0},{1,1,2},{2,1,-2},{3,-1,2},{4,-1,-2},{5,2,1},{6,2,-1},{7,-2,1},{8,-2,-1},{9,0,0}}; //定义棋子行走规则Push(a,x);//向栈x输入起始位置x的值Push(b,y);//向栈y输入起始位置y的值int c[65]={0};//用于储存棋子在每个位置时所选择的路径编号for(i=1;i<3;i++){c[i]++;if(c[i]==9)//如果当前位置的棋子8个路径均不可用，则将当前位置编号置0，从栈x、y中pop出上一步棋子的位置，并设置为当前位置{c[i]=0;i=i-2;qipan[a][b]=0;Pop(x);a=e;Pop(y);b=e;continue;}m=a+step[c[i]][1];n=b+step[c[i]][2];while((!(m>0&&m<9&&n>0&&n<9))||(qipan[m][n]!=0))//当所选路径不合法时，选择下一条路径{c[i]++;//路径编号递增m=a+step[c[i]][1];n=b+step[c[i]][2];if(c[i]==9)//如果当前位置的棋子8个路径均不可用，则将当前位置编号置0，从栈x、y中pop出上一步棋子的位置，并设置为当前位置{qipan[a][b]=0;Pop(x);a=e;Pop(y);b=e;break;}}if(c[i]==9)//若当前棋子无路可走，将路径编号置0后，将位置编号回溯{c[i]=0;i=i-2;continue;}qipan[m][n]=i+1;//若路径可用，将移动后的位置输入栈内，并将当前位置设置为移动后的位置Push(m,x);Push(n,y);a=m;b=n;}int p,q;for(p=1;p<9;p++)//输出解决方案{for(q=1;q<9;q++)printf("%3d",qipan[p][q]);printf("\n");}}int main()//主函数{int a,b;Stack x=CreateStack();Stack y=CreateStack();printf("请输入马的初始位置（x,y），以空格隔开，其中x、y均为1~8区间内的整数\n");scanf("%d%d",&a,&b);solve(a,b,x,y);DisposeStack(x);DisposeStack(y);｝四.运行结果：1.hanoi塔问题：2.马踏棋盘：五.实验心得：在本课程设计中，我明白了理论与实际应用相结合的重要性，并提高了自己组织数据及编写大型程序的能力。

东软数据结构实验报告——通过栈和队列来实现进制转换

实验报告（一）实验过程一、项目简介进制转换通过编写函数实现十进制浮点数到R进制的转换，在十进制浮点数的整数部分利用栈结构实现，小数部分用队列结构实现。

二、项目实施：1.读取数据并获得小数点位置2.将字符串转为整数形式.3.对整数部分进行入栈4.获得小数部分并入队5.整数和小数的联合输出6.源代码：#include <stdio.h>#include <string.h>#include <math.h>#define size 10 //小数部分大小#define maxsize 20 //整数部分大小//*********************************//*********************************//小数部分——队列typedef struct{char data[10]; //读取转制后的小数部分int front,rear; //队首尾指针}Queue; //循环队列//*********************************//初始化队列void init_Queue(Queue* q){q->front=q->rear=0;}//*********************************//入队int push_Queue(Queue *q,int x){if((q->rear+1)%size==q->front) //判断队满{printf("队列满！不允许入队\n");return 0;}else{q->rear=(q->rear+1) % size;q->data[q->rear]=x;return 1;}}//********************************* //出队int pop_Queue(Queue *q,int *x){if(q->rear==q->front){printf("队空！");return 0;}else{q->front=(q->front+1)%size;*x=q->data[q->front]; //读取队头元素return 1;}}//*********************************//*********************************//整数部分——栈typedef struct{char dataint[100];int top;}Stack;//*********************************//-制空栈void init_Stack(Stack *s){s->top=0;}//*********************************//进栈int push_Stack(Stack *s,int x){if(s->top==maxsize){printf("栈已满！");return 0;}else{s->dataint[s->top]=x; //数据进栈s->top++;return 1;}}//*********************************//出栈int pop_Stack(Stack *s,int *x){if(s->top==0){printf("栈空，无数据可取!");return 0;}else{s->top--;*x=s->dataint[s->top]; //取处数据return 1;}}//********************************* 主程序int main(){//*********************************//读入数据char a[20];int aim;printf("请输入一个十进制浮点数： "); //以字符串形式输入一个浮点数gets(a);printf("请输入目标进制： ");scanf("%d",&aim);if(aim==1) {printf("ERROR! PLEASE INPUT A NUMBER AND IT IS BIGGER THAN 1");return 0;}//*********************************//读取小数点位置int i;int pos;//小数点位置for(i=0;i<strlen(a);++i){if(a[i]=='.'){pos=i;break;}}//*********************************//定义栈对整数部分转化后并入栈Stack ss;init_Stack(&ss);//初始化栈//*********************************//将整数部分转换为 int 型int begin=1;int bnum;if(a[0]=='-') {int bnum = a[1]-'0'; //判断是否为负数begin=2;}else bnum=a[0]-'0';for(i=begin;i<pos;i++){bnum=bnum*10+a[i]-'0';}// printf("整数部分：%d\n",bnum);//依次求得所转进制的每一位并入栈while(bnum){// if(bnum/aim!=0)push_Stack(&ss,bnum%aim);bnum=bnum/aim;}//*********************************//出栈读取整数部分结果int flag,z;flag=pop_Stack(&ss,&z);if(flag==1){printf("目的进制数为： ");for(i=ss.top;i>=0;i--) //先从顶端出栈printf("%d ",ss.dataint[i]);}else printf("无数据！");// printf("\n");//定义队列并将小数部分转化后入队Queue q,*cq=&q;init_Queue(cq);//*********************************//将小数点后面的部分转为浮点数int c=1;int anum=a[pos+1]-'0';for(i=pos+2;i<strlen(a);i++){anum=anum*10+(a[i]-'0');c++;}double small=((double)anum)/pow(10,c); // printf("小数部分：%lf\n",small);//*********************************// 依次求得小数部分的每一位并入队int zz;int innum;for(i=0;i<6;i++){innum=(((int)(small*aim)))%10; //取出小数点前的部分small=small*aim-innum; //得到减去小数点前段的部分继续与aim 相乘push_Queue(cq,innum);}//*********************************//出队列printf(".") ;if(pop_Queue(cq,&zz)){for(i=(cq->front)%size;i!=(cq->rear+1)%size;i=(i+1)%size)printf("%d ",cq->data[i]);}//*********************************return 0;}实验总结通过对数据的单个读取并入栈，后续的出栈顺序为从上到下，先进后出，读取数据后为相反的顺序，而队列的顺序出队为先进先出，对小数的存储可直接进行读取。

实验报告——栈和队列的应用

实验报告——栈和队列的应用第一篇：实验报告——栈和队列的应用实验5 栈和队列的应用目的和要求：（1）熟练栈和队列的基本操作；（2）能够利用栈与队列进行简单的应用。

一、题目题目1.利用顺序栈和队列，实现一个栈和一个队列，并利用其判断一个字符串是否是回文。

所谓回文，是指从前向后顺读和从后向前倒读都一样的字符串。

例如，a+b&b+a等等。

题目2.假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。

跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。

若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。

现要求写一算法模拟上述舞伴配对问题，并实现。

题目3.打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。

每台打印机具有一个队列（缓冲池），用户提交打印请求被写入到队列尾，当打印机空闲时，系统读取队列中第一个请求，打印并删除之。

请利用队列的先进先出特性，完成打印机网络共享的先来先服务功能。

题目4.假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag，以tag == 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。

试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。

题目5.利用循环链队列求解约瑟夫环问题。

请大家从本组未讨论过的五道题中选择一道，参照清华邓俊辉老师MOOC视频及课本相关知识，编写相应程序。

选择题目3：打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。

二、程序清单//Ch3.cpp #include #include #include“ch3.h” template void LinkedQueue::makeEmpty()//makeEmpty//函数的实现{ LinkNode*p;while(front!=NULL)//逐个删除队列中的结点{p=front;front=front->link;delete p;} };template bool LinkedQueue::put_in(T&x）{//提交命令函数if(front==NULL){//判断是否为空front=rear=new LinkNode;//如果为空，新结点为对头也为对尾front->data=rear->data=x;if(front==NULL)//分配结点失败return false;} else{rear->link=new LinkNode;//如不为空，在链尾加新的结点rear->link->data=x;if(rear->link==NULL)return false;rear=rear->link;} return true;};template bool LinkedQueue::carry_out()//执行命令函数 { if(IsEmpty()==true)//判断是否为空{return false;} cout<data<LinkNode*p=front;front=front->link;//删除以执行的命令，即对头修改delete p;//释放原结点return true;};void main()//主函数 { LinkedQueue q;//定义类对象char flag='Y';//标志是否输入了命令const int max=30;//一次获取输入命令的最大个数while(flag=='Y')//循环{ int i=0;char str[max];//定义存储屏幕输入的命令的数组gets(str);//获取屏幕输入的命令while(str[i]!=''){q.put_in(str[i]);//调用提交命令函数，将每个命令存入队列中i++;}for(int j=0;j<=i;j++){if(q.IsEmpty()==true)//判断是否为空，为空则说明没有可执行的命令{cout<cin>>flag;continue;//为空跳出for循环为下次输入命令做好准备}q.carry_out();//调用执行命令的函数，将命令打印并删除}三、程序调试过程中所出现的错误无。

【电大本科数据结构实验报告】栈和队列的基本操作

实验报告（学科：数据结构）姓名__________________单位_______________________班级______________________实验名称：2.1 栈和队列的基本操作【问题描述】编写一个算法，输出指定栈中的栈底元素，并使得原栈中的元素倒置。

【基本要求】（1）正确理解栈的先进后出的操作特点，建立初始栈，通过相关操作显示栈底元素。

（2）程序中要体现出建栈过程和取出栈底元素后恢复栈的入栈过程，按堆栈的操作规则打印结果栈中的元素。

【实验步骤】（1）建立顺序栈SeqStack，存放测试数据；建立队列SeqQueue存放出栈数据；（2）建立InitStack、StackEmpty、StackFull、Pop、Push、GetTop函数用作顺序栈的基本操作；（3）建立InitQueue、QEmpty、Qfull、InQueue、OutQueue、ReadFront函数用作队列的基本操作；（4）建立主函数依次按序对子函数进行操作：InitStack初始化栈→Push压入数据→InitQueue初始化队列→Pop弹出数据→InQueue存入队列→OutQueue出队列→Push压入栈→Pop弹出数据→free清空栈与队列。

在数据的输入与数据的输出时提供必要的提示信息。

（5）使用Visual Studio C++ 2005语言环境进行调试，源代码P202-2-1.cpp通过编译生成目标文件P202-2-1.obj，运行可执行文件：实验2-2-1.exe测试通过。

【源代码】#include "stdio.h"#include "stdlib.h"#define MaxSize 8typedef int ElemType;/*顺序栈的类型定义*/struct SeqStack{ElemType data[MaxSize];int top;};struct SeqStack * s;/*顺序队列的类型定义*/struct SeqQueue{ElemType data[MaxSize];int front,rear;};struct SeqQueue * sq;/*栈的基本运算*//*初始化栈操作*/void InitStack(struct SeqStack * s){s->top=-1;}/*判断栈空操作*/int StackEmpty(struct SeqStack * s){if(s->top==-1){ return(1);}else{return(0);}}/*判断栈满操作*/int StackFull(struct SeqStack * s){if(s->top==MaxSize-1){ return(1);}else{ return(0);}}/*压栈操作*/void Push(struct SeqStack *s,ElemType x) {if(s->top==MaxSize-1){printf("栈满溢出错误!\n");exit(1);}s->top++;s->data[s->top]=x;}/*弹栈操作*/ElemType Pop(struct SeqStack * s){if(StackEmpty(s)){printf("栈下溢错误!!\n");return(1);}s->top--;return s->data[s->top+1];}/*获取栈顶元素操作*/ElemType GetTop(struct SeqStack * s){if(StackEmpty(s)){printf("栈下溢错误!\n");exit(1);}return s->data[s->top];}/*队列的基本运算*//*初始化队列*/void InitQueue(struct SeqQueue * sq){sq->front=0;sq->rear=0;}/*判队空*/int QEmpty(struct SeqQueue * sq){if(sq->front==sq->rear){printf("队列已空，不能进行出队操作!\n");return(1); /*如果链队为空，则返回*/}else{return(0); /*否则返回*/ };}/*判队满*/int Qfull(struct SeqQueue * sq){if(sq->rear==MaxSize){ /*判队列是否已满*/printf("队列已满!\n");return(1); /*入队失败，退出函数运行*/ }return(0);}/*入队列操作*/void InQueue(struct SeqQueue * sq, int x){if(!Qfull(sq)){sq->data[sq->rear]=x; /*数据送给队尾指针所指单元*/sq->rear++; /*将队尾指针加*/ }}/*出队列操作*/ElemType OutQueue(struct SeqQueue *sq){if(sq->rear==sq->front){ /*判断队列是否为空*/printf("队列已空，不能进行出队操作!!\n");return(1); /*出队失败，退出函数运行*/ }sq->front++;return sq->data[sq->front-1];}/*读队头元素*/void ReadFront(struct SeqQueue * sq,int x){if(!QEmpty(sq)){sq->front++; /*将头指针加,前移*/OutQueue(sq); /*出队列操作*/ }}void main(){int n;struct SeqStack *a=(SeqStack *)malloc(sizeof(struct SeqStack));/*分配栈的内存空间，使结构指针a指向栈地址*/struct SeqQueue *sq=(SeqQueue *)malloc(sizeof(struct SeqQueue));InitStack(a);do{printf("输入栈中的数据:");scanf("%d",&n);Push(a,n);/*把数据压入栈中*/}while(!StackFull(a));InitQueue(sq);do{InQueue(sq,Pop(a)); /*弹出栈数据，把数据放进队列中*/}while(!(StackEmpty(a)&&Qfull(sq)));do{Push(a,OutQueue(sq)); /*从队列输出数据，把数据压入到栈内*/}while(!(QEmpty(sq)&&StackFull(a)));do{printf("输出栈中的数据:%d\n",Pop(a)); /*弹出栈中所有数据*/ }while(!StackEmpty(a));free(a);free(sq);}【实验数据】【结论】由于栈的结构特点决定了栈对数据的操作规则。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

实验二堆栈和队列实验目的：1.熟悉栈这种特殊线性结构的特性；2.熟练并掌握栈在顺序存储结构和链表存储结构下的基本运算；3.熟悉队列这种特殊线性结构的特性；3.熟练掌握队列在链表存储结构下的基本运算。

实验原理：堆栈顺序存储结构下的基本算法；堆栈链式存储结构下的基本算法；队列顺序存储结构下的基本算法；队列链式存储结构下的基本算法；实验内容：第一题链式堆栈设计。

要求（1）用链式堆栈设计实现堆栈，堆栈的操作集合要求包括：初始化StackInitiate（S）,非空否StackNotEmpty(S)，入栈StackiPush(S,x),出栈StackPop（S,d）,取栈顶数据元素StackTop(S,d);（2）设计一个主函数对链式堆栈进行测试。

测试方法为：依次把数据元素1，2，3，4，5入栈，然后出栈并在屏幕上显示出栈的数据元素；（3）定义数据元素的数据类型为如下形式的结构体，Typedef struct{char taskName[10];int taskNo;}DataType;首先设计一个包含5个数据元素的测试数据，然后设计一个主函数对链式堆栈进行测试，测试方法为：依次吧5个数据元素入栈，然后出栈并在屏幕上显示出栈的数据元素。

第二题对顺序循环队列，常规的设计方法是使用対尾指针和对头指针，对尾指针用于指示当前的対尾位置下标，对头指针用于指示当前的対头位置下标。

现要求：（1）设计一个使用对头指针和计数器的顺序循环队列抽象数据类型，其中操作包括：初始化，入队列，出队列，取对头元素和判断队列是否为空；（2）编写主函数进行测试。

程序代码：第一题：（1）源程序"LinStack.h"如下：#define NULL 0typedef struct snode{ DataType data;struct snode *next;} LSNode;/*（1）初始化StackInitiate(LSNode ** head) */void StackInitiate(LSNode ** head)/*初始化带头结点链式堆栈*/{ if((*head=(LSNode *)malloc(sizeof(LSNode)))==NULL)exit(1);(*head)->next=NULL;}/*（2）非空否StackNotEmpty(LSNode * head) */int StackNotEmpty(LSNode * head)/*判断堆栈是否为空，非空返回1，否则返回0*/{ if(head->next==NULL) return 0;else return 1;}/*（3）入栈StackPush(LSNode * head, DataType x) */ int StackPush(LSNode *head, DataType x)/*把数据元素x插压入链式堆栈head的栈顶作为新的栈顶，*//*入栈成功返回1，否则返回0 */{ LSNode *p;if((p=(LSNode *)malloc(sizeof(LSNode)))==NULL){ printf("The memory space is not enough!\n");return 0;}p->data=x;p->next=head->next; /*新结点入栈*/head->next=p; /*新结点成为新的栈顶*/return 1;}/*（4）出栈StackPop(SLNode *head, DataType *d) */int StackPop(LSNode *head, DataType *d)/*出栈并把栈顶数据元素值带到参数d，*//*出栈成功返回1，否则返回0 */{ LSNode *p;p=head->next;if(p==NULL){ printf("The Stack has been empty!\n");return 0;}head->next=p->next;*d=p->data;free(p);return 1;}/*（5）取栈顶数据元素StackTop(LSNode *head, DataType *d) */ int StackTop(LSNode *head, DataType *d)/*取栈顶数据元素并由参数d带回，*//* 成功返回1，否则返回0 */{ LSNode *p;p=head->next;if(p==NULL){ printf("The Stack has been empty!\n");return 0;}*d=p->data;return 1;}/*（6）撤销动态申请空间Destroy(LSNode *head) */ void Destroy(LSNode *head){ LSNode *p, *p1;p=head;while(p!=NULL){ p1=p;p=p->next;free(p1);}}（2）测试函数如下：#include<stdio.h>/*该文件包含printf()函数*/#include<stdlib.h>/*该文件包含exit()函数*/#define NULL 0typedef int DataType;#include "LinStack.h"void main(void){ LSNode *myStack;int i, x;StackInitiate(&myStack);for(i=0;i<5; i++){ if(StackPush(myStack,i+1)==0){printf("error!\n");return;}}if(StackTop(myStack, &x)==0){printf("error!\n");return;}elseprintf("The element of local top is :%d\n",x);printf( "The sequence of outing elements is:\n");while(StackNotEmpty(myStack)){StackPop(myStack, &x);printf("%d ", x);}Destroy(myStack);}（3）设计结构体和测试函数如下：#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef struct{char taskName[10];int taskNo;}DataType;#include"LinStack.h"void main(){LSNode *myStack;FILE *fp;DataType task,x;if((fp=fopen("task.dat","r"))==NULL){printf("不能打开文件task.dat!\n");exit(0);}StackInitiate(&myStack);while(!feof(fp)){fscanf(fp,"%s %d",&task.taskName,&task.taskNo);StackPush(myStack,task);}fclose(fp);while(StackNotEmpty(myStack)){StackPop(myStack,&x);printf("%s %d\n",x.taskName,x.taskNo);}Destroy(myStack);}其中task.dat为：第一个 1第二个 2第三个 3第四个 4第五个 5第二题：原函数设计如下：typedef struct{DataType queue[MaxQueueSize];int front; /*队头指针*/int count; /*计数器*/} SeqCQueue;/*==========================*//*(1)初始化QueueInitiate(SeqCQueue *Q) */void QueueInitiate(SeqCQueue *Q)/*初始化顺序循环队列Q */{Q->front=0; /*定义初始队头指针下标*/Q->count=0; /*定义初始计数器值*/}/*==========================*//*(2)非空否QueueNotEmpty(SeqCQueue Q)*/int QueueNotEmpty(SeqCQueue Q)/*判断顺序循环队列Q非空否，非空时返回1，否则返回0 */{if(Q.count!=0)return 1;else return 0;}/*==========================*//*(3)入队列QueueAppend(SeqCQueue *Q, DataType x)*/int QueueAppend(SeqCQueue *Q, DataType x)/*把数据元素x插入顺序循环队列Q的队尾，成功时返回1，否则返回0 */ {if(Q->count==MaxQueueSize){printf("The queue is full!\n");return 0;}else{ int r;r=Q->front+Q->count;Q->queue[r]=x;Q->count++;return 1;}}/*==========================*//*(4)出队列QueueDelete(SeqCQueue *Q, DataType *d)*/int QueueDelete(SeqCQueue *Q, DataType *d)/*删除顺序循环队列队头数据元素并赋值d，成功时返回1，否则返回0 */ {if(Q->count==0){printf("The queue is empty!\n");return 0;}else{*d=Q->queue[Q->front];Q->front=(Q->front+1)%MaxQueueSize;Q->count--;return 1;}}/*==========================*//*(6)取对头数据元素QueueGet(SeqCQueue Q, DataType *d)*/int QueueGet(SeqCQueue Q, DataType *d)/* 取顺序循环队列队头数据元素并赋值d，成功时返回1，否则返回0 */ {if(Q.count==0){printf("The queue is empty!\n");return 0;}else{*d=Q.queue[Q.front];return 1;}}（2）测试函数如下：#include<stdio.h>#define MaxQueueSize 100typedef int DataType;#include"SeqQueue.h"void main(void){int i,j,d;SeqCQueue myQueue;QueueInitiate(&myQueue);printf("%d\n",QueueNotEmpty(myQueue)); /*判空*/for(i=0;i<=10;i++){if(QueueAppend(&myQueue,i+1)==0)break;}printf("%d\n",myQueue.count); /*输出元素个数*/ for(j=0;j<=9;j++){if(QueueDelete(&myQueue,&d)==0)break;printf("%d ",d); /*出队列并显示元素*/}printf("\n");printf("%d\n",QueueNotEmpty(myQueue)); /*再次判空*/}实验结果：（1）测试函数输出结果如下：（2）测试设计的结构体结果如下：（3）测试仅使用头指针和计数器的队列结果如下：总结与思考只使用对头指针和计数器的循环队列，实现方法和加上尾指针只有在入队列操作时有所不同，其他的都一样；而此时，入队列元素的位置就由对头指针和计数器决定，此算法的清晰度（可读性）比不上有尾指针的循环队列；但是在判空以及循环具体操作时更为方便；在以结构体数据类型的操作中，要注意的是，取数据元素时也要用结构体类型的变量去取出，输出时也一样。

相关文档
最新文档