《数据结构》实验二 栈和队列
数据结构实验报告-栈和队列
2007级数据结构实验报告实验名称：实验2——栈和队列学生姓名：班级：班内序号：学号：日期：2008年11月X日1．实验要求题目1根据栈和队列的抽象数据类型的定义，按要求实现一个栈或一个队列。
要求：1、实现一个共享栈2、实现一个链队列3、编写测试main()函数测试线性表的正确性2. 程序分析2.1 存储结构ADT StackData栈中元素具有相同类型及后进先出特性，相邻元素具有前驱和后继关系OperationInitStack前置条件：栈不存在输入：无功能：栈的初始化输出：无后置条件：构造一个空栈DestroyStack前置条件：共享空间已存在输入：无功能：销毁两栈共享的数组空间输出：无后置条件：将两栈共享的数组空间释放Push前置条件：共享空间已存在输入：栈号i，元素值x功能：在栈i顶插入一个元素x输出：若插入不成功，则抛出插入异常后置条件：若插入成功，则栈i顶插入了一个栈顶元素 Pop前置条件：共享空间已存在输入：栈号i功能：在栈i中删除栈顶元素输出：若删除不成功，则抛出删除异常后置条件：若删除成功，则栈i中删除了栈顶元素GetTop前置条件：共享空间已存在输入：栈号i功能：读取栈i当前的栈顶元素输出：若栈i不空，返回栈i当前的栈顶元素值后置条件：两栈均不变Empty前置条件：共享空间已存在输入：栈号i功能：判断栈i是否为空栈输出：若栈i为空栈，返回1；否则返回0后置条件：两栈均不变endADTADT StackData队列中元素具有相同类型及后进后出特性，相邻元素具有前驱和后继关系OperationInitQueue前置条件：队列不存在输入：无功能：初始化队列输出：无后置条件：创建一个空队列EnQueue前置条件：队列已存在输入：元素值s功能：在队尾插入一个元素输出：无后置条件：如果插入成功，队尾增加了一个元素DeQueue前置条件：队列已存在输入：无功能：删除队头元素输出：如果删除成功，返回被删元素值，否则，抛出删除异常后置条件：如果删除成功，队头减少了一个元素GetQueue前置条件：队列已存在输入：无功能：读取队头元素输出：若队列不空，返回队头元素后置条件：队列不变Empty前置条件：队列已存在输入：无功能：判断队列是否为空输出：如果队列为空，返回，否则，返回后置条件：队列不变endADT2.2 关键算法分析在一个程序中如果需要同时使用具有相同数据类型的两个栈时，如何处理：使用一个数组来存储两个栈，让一个栈的栈底为该数组的始端，另一个栈的栈底为该数组的末端，每个栈从各自的端点向中间延伸，如图所示。
数据结构栈和队列
实验二栈和队列一、实验目的1、掌握栈的特点(先进后出FILO)及基本操作，如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。
2、掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等，队列顺序存储结构、链式存储结构和循环队列的实现，以便在实际问题背景下灵活应用。
二、实验内容1、顺序栈的实现和运算；2、循环队列的实现和运算；3、栈的运用—十进制转八进制运算。
三、实验要求1、学生用C++/C完成算法设计和程序设计并上机调试通过；2、撰写实验报告，提供实验测试数据和实验结果；3、分析算法，要求给出具体的算法分析结果，包括时间复杂度和空间复杂度，并简要给出算法设计小结和心得。
四、实验准备1、掌握栈和队列这两种抽象数据类型的特点，并能在相应的应用任务中正确选用它们；2、熟练掌握顺序栈和循环队列的基本操作实现算法，特别应注意栈满和栈空的条件以及它们的描述方法，循环队列中队满和队空的描述方法。
3、在学习顺序栈的基本操作实现算法时，应注意：在书上给出的结构定义是采用了一种动态管理方式（不够时，可以再分配），但在C 语言中，用数组来存储顺序栈，是静态分配，即不能随机分配空间，这点易引起大家的误解。
五、实验步骤1、编程实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：(1)初始化顺序栈；(2)给定一个元素，将此元素压入此栈中；(3)将栈顶一个元素弹出此栈。
2、编写一个程序实现循环队列的各种基本运算，并在此基础上设计一个主程序，完成如下功能：(1)初始化循环队列；(2)给定一个元素，将此元素插入此队列中；(3)将队头一个元素出队。
3、栈的运用实例十进制转八进制。
六、实验参考代码1、顺序栈的实现和运算；#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType;typedef int Status;//----- 栈的顺序存储表示-----#define STACK_INIT_SIZE 100 // 存储空间的初始分配量#define STACKINCREMENT 10 // 存储空间的分配增量typedef struct {ElemType *base;ElemType *top;int stacksize;} SqStack;// 构造一个空栈SStatus InitStack(SqStack &S){S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));if(!S.base) exit (OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}// 判栈S是否为空栈Status StackEmpty(SqStack S){if (S.top==S.base) return OK;else return ERROR;}//入栈函数Status Push (SqStack &S, ElemType e) {if(S.top - S.base >= S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)* sizeof(ElemType)); if(!S.base) exit (OVERFLOW);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;}//输出顺序栈函数void OutStack(SqStack S){ int *p;if(S.top == S.base){printf("这是一个空栈！");}elsefor(p= S.top-1; p>= S.base;p--)printf("%6d", *p);printf("\n");}//主函数void main(){ SqStack s;int cord; ElemType a;printf("第一次使用必须初始化！\n");do{printf("\n 主菜单\n");printf(" 1 初始化顺序栈");printf(" 2 插入一个元素");printf(" 3 删除栈顶元素");printf(" 4 结束程序运行");printf("\n------------------------------------------------------------------------------\n"); printf("请输入您的选择( 1, 2, 3, 4)");scanf("%d",&cord);printf("\n");switch(cord){ case 1:InitStack(s);OutStack(s);break;case 2:printf("请输入要插入的数据元素：a=");scanf("%d",&a);Push(s,a);printf("%d 进栈之后的栈：",a);OutStack(s);break;case 3:Pop(s,a);printf("栈顶元素%d 出栈之后的栈：",a);OutStack(s);break;case 4:exit(0);}}while (cord<=4);}2、循环队列的实现和运算；#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int QElemType;typedef int Status;//----- 队列的顺序存储表示-----#define MAXQSIZE 100 // 存储空间的初始分配量typedef struct {QElemType *base;int front;int rear;} SqQueue;// 构造一个空队列QStatus InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base)exit(OVERFLOW);Q.front=Q.rear=0;return OK;}//判队列是否为空Status QueueEmpty (SqQueue Q) {if(Q.rear==Q.front) return OK;else return ERROR ;}//入队函数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.rear==Q.front) return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}//输出循环队列函数void OutQueue(SqQueue Q)if(Q.front == Q.rear){printf("这是一个空队列！");}else{n= (Q.rear- Q.front+ MAXQSIZE) % MAXQSIZE;i= 1;while ( i<= n){printf("%6d", Q.base[(Q.front+i-1)% MAXQSIZE] );i++;}printf("\n");}}//主函数void main(){ SqQueue q;int cord; QElemType a;printf("第一次使用必须初始化！\n");do{printf("\n 主菜单\n");printf(" 1 初始化循环队列");printf(" 2 进队一个元素");printf(" 3 出队一个元素");printf(" 4 结束程序运行");printf("\n------------------------------------------------------------------------------\n"); printf("请输入您的选择( 1, 2, 3, 4)");scanf("%d",&cord);printf("\n");switch(cord){ case 1:InitQueue(q); //调用初始化算法;OutQueue(q);break;case 2:printf("请输入要插入的数据元素：a=");scanf("%d",&a);EnQueue (q, a); //调用进队算法;printf("%d 进队之后的队列：",a);OutQueue(q);break;case 3:DeQueue (q, a); //调用出队算法;printf("队头元素%d 出队之后的队列：",a);OutQueue(q);break;exit(0);}}while (cord<=4);}3、栈的应用—十进制转八进制#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType;typedef int Status;#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct {ElemType *base;ElemType *top;int stacksize;} SqStack;// 构造一个空栈SStatus InitStack(SqStack &S){S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));if(!S.base) exit (OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}// 判栈S是否为空栈Status StackEmpty(SqStack S){if (S.top==S.base) return OK;else return ERROR;}//入栈函数Status Push (SqStack &S, ElemType e) {if(S.top - S.base >= S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)* sizeof(ElemType)); if(!S.base) exit (OVERFLOW);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;}//十进制转八进制函数void conversion(){ SqStack S;int n,e;InitStack(S);printf("请输入一个十进制数：");scanf("%d",&n);while(n){Push(S,n%8);n=n/8;}printf("转换之后的八进制数为：");while(!StackEmpty(S)){Pop(S, e);printf("%d",e);}printf("\n");}void main(){conversion();}（注：文档可能无法思考全面，请浏览后下载，供参考。
数据结构栈和队列实验报告
数据结构栈和队列实验报告实验报告：数据结构栈和队列一、实验目的1.了解栈和队列的基本概念和特点；2.掌握栈和队列的基本操作；3.掌握使用栈和队列解决实际问题的方法。
二、实验内容1.栈的基本操作实现；2.队列的基本操作实现；3.使用栈和队列解决实际问题。
三、实验原理1.栈的定义和特点：栈是一种具有后进先出(LIFO)特性的线性数据结构，不同于线性表，栈只能在表尾进行插入和删除操作，称为入栈和出栈操作。
2.队列的定义和特点：队列是一种具有先进先出(FIFO)特性的线性数据结构，不同于线性表，队列在表头删除元素，在表尾插入元素，称为出队和入队操作。
3.栈的基本操作：a.初始化：建立一个空栈；b.入栈：将元素插入栈的表尾；c.出栈：删除栈表尾的元素，并返回该元素；d.取栈顶元素：返回栈表尾的元素，不删除。
4.队列的基本操作：a.初始化：建立一个空队列；b.入队：将元素插入队列的表尾；c.出队：删除队列表头的元素，并返回该元素；d.取队头元素：返回队列表头的元素，不删除。
四、实验步骤1.栈的实现：a.使用数组定义栈，设置栈的大小和栈顶指针；b.实现栈的初始化、入栈、出栈和取栈顶元素等操作。
2.队列的实现：a.使用数组定义队列，设置队列的大小、队头和队尾指针；b.实现队列的初始化、入队、出队和取队头元素等操作。
3.使用栈解决实际问题：a.以括号匹配问题为例，判断一个表达式中的括号是否匹配；b.使用栈来实现括号匹配，遍历表达式中的每个字符，遇到左括号入栈，遇到右括号时将栈顶元素出栈，并判断左右括号是否匹配。
4.使用队列解决实际问题：a.以模拟银行排队问题为例，实现一个简单的银行排队系统；b.使用队列来模拟银行排队过程，顾客到达银行时入队，处理完业务后出队，每个顾客的业务处理时间可以随机确定。
五、实验结果与分析1.栈和队列的基本操作实现：a.栈和队列的初始化、入栈/队、出栈/队以及取栈顶/队头元素等操作均能正常运行；b.栈和队列的时间复杂度均为O(1)，操作效率很高。
数据结构栈和队列实验报告
数据结构栈和队列实验报告数据结构栈和队列实验报告1.实验目的本实验旨在通过设计栈和队列的数据结构，加深对栈和队列的理解，并通过实际操作进一步掌握它们的基本操作及应用。
2.实验内容2.1 栈的实现在本实验中，我们将使用数组和链表两种方式实现栈。
我们将分别实现栈的初始化、入栈、出栈、判断栈是否为空以及获取栈顶元素等基本操作。
通过对这些操作的实现，我们可将其用于解决实际问题中。
2.2 队列的实现同样地，我们将使用数组和链表两种方式实现队列。
我们将实现队列的初始化、入队、出队、判断队列是否为空以及获取队头元素等基本操作。
通过对这些操作的实现，我们可进一步了解队列的特性，并掌握队列在实际问题中的应用。
3.实验步骤3.1 栈的实现步骤3.1.1 数组实现栈（详细介绍数组实现栈的具体步骤）3.1.2 链表实现栈（详细介绍链表实现栈的具体步骤）3.2 队列的实现步骤3.2.1 数组实现队列（详细介绍数组实现队列的具体步骤）3.2.2 链表实现队列（详细介绍链表实现队列的具体步骤）4.实验结果与分析4.1 栈实验结果分析（分析使用数组和链表实现栈的优缺点，以及实际应用场景）4.2 队列实验结果分析（分析使用数组和链表实现队列的优缺点，以及实际应用场景）5.实验总结通过本次实验，我们深入了解了栈和队列这两种基本的数据结构，并利用它们解决了一些实际问题。
我们通过对数组和链表两种方式的实现，进一步加深了对栈和队列的理解。
通过实验的操作过程，我们也学会了如何设计和实现基本的数据结构，这对我们在日后的学习和工作中都具有重要意义。
6.附件6.1 源代码（附上栈和队列的实现代码）6.2 实验报告相关数据（附上实验过程中所产生的数据）7.法律名词及注释7.1 栈栈指的是一种存储数据的线性数据结构，具有后进先出(LIFO)的特点。
栈的操作主要包括入栈和出栈。
7.2 队列队列指的是一种存储数据的线性数据结构，具有先进先出(FIFO)的特点。
数据结构栈和队列实验报告
3检查一遍已输入的程序是否有错〔包括输入时输错的和编程中的错误〕，如发现有错，及时改正。
4进展编译和连接。如果在编译和连接过程中发现错误，频幕上会出现"报错信息〞，根据提示找到出错位置和原因，加以改正。再进展编译，如此反复直到不出错为止。
5运行程序并分析运行结果是否合理。在运行是要注意当输入不同的数据时所得结果是否正确，应运行屡次，分别检查在不同情况下结果是否正确。
s->ne*t=NULL;
}
void DestroyStack(LiStack *&s)//销毁栈
{LiStack *p=s,*q=s->ne*t;
while (q!=NULL)
{free(p);
p=q;
q=p->ne*t;
}
free(p);//此时p指向尾节点,释放其空间
}
bool StackEmpty(LiStack *s)//判断栈是否为空
printf("栈s的根本运算如下:\n");
printf(" (1)初始化栈s\n");
InitStack(s);
printf(" (2)栈为%s\n",(StackEmpty(s)""空":"非空"));
printf(" (3)依次进栈元素a,b,c,d,e\n");
Push(s,'a');Байду номын сангаас
Push(s,'b');
#include <stdio.h>
#include <malloc.h>
#define Ma*Size 100
数据结构实验报告2栈、队列、递归程序设计
日期：学号：姓名：
实验名称：实验报告二栈、队列、递归程序设计
实验目的与要求：
2.1栈和队列的基本操作
（1）正确理解栈的先进后出的操作特点，建立初始栈，通过相关操作显示栈底元素。
（2）程序中要体现出建栈过程和取出栈底元素后恢复栈的入栈过程，按堆栈的操作规则打印结果栈中的元素
{
return(s->top==-1);
}
//---出栈函数
int Pop(SeqStack *&s,ElemType &e)
{
if (s->top==-1)
return 0;
e=s->data[s->top];
s->top--;
return 1;
}
//---初始队列函数
void InitQueue(SqQueue *&q)
q->rear=(q->rear+1)%MaxSize;
q->elem[q->rear]=e;
return 1;
}
//---出队列函数
int OutQueue(SqQueue *&q,ElemType &e)
{
if (q->front==q->rear) //队空
return 0;
q->front=(q->front+1)%MaxSize;
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(q)?"空":"非空"));
栈和队列的基本操作实验报告
《数据结构》实验报告一软件132201300514211徐蜀实验二栈和队列的基本操作及其应用一、实验目的1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。
2、掌握栈和队列的特点，即后进先出和先进先出的原则。
3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序存储结构和链式存储结构上的实现。
二、实验内容1．回文判断三、实验要求1、按照数据结构实验任务书，提前做好实验预习与准备工作。
2、加“*”题目必做，其他题目任选；多选者并且保质保量完成适当加分。
3、严格按照数据结构实验报告模板和规范，及时完成实验报告。
四、实验步骤（说明：依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作（函数）的伪码算法、函数实现、程序编码、调试与分析。
附流程图与主要代码）㈠、数据结构与核心算法的设计描述（程序中每个模块或函数应加注释，说明函数功能、入口及出口参数）1、栈的初始长度与需要再增加的长度#define STACK_INIT_SIZE 100;#define STACKINCREMENT 10;typedef char SElemType;//定义SElemType为char型2、栈的顺序存储表示typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;3、队列的链式表示方法typedef struct QNode {SElemType data;struct QNode *next; } QNode, *QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;4、初始化栈/* 函数功能：对栈进行初始化参数：栈（SqStack &S）成功返回1，否则返回0 */int InitStack(SqStack &S){S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));//申请内存if(!S.base) //判断有无申请到空间return ERROR; //没有申请到内存，返回0S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}5、入栈操作/* 函数功能：将元素入栈参数：栈（SqStack &S）,插入元素e插入成功返回1，否则返回0 */int 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) //判断是否申请成功return ERROR; //不成功返回0S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}6、出栈操作/* 函数功能：将栈中的元素弹出参数：栈(SqStack &S),记录元素e */int Pop(SqStack &S, SElemType &e){if(S.top == S.base) //判断栈是否为空return ERROR;e = *(--S.top) ;return OK;}7、初始化队列/* 函数功能：初始化队列参数：队列（LinkQueue &Q）成功返回1，否则返回0 */int InitQueue(LinkQueue &Q){Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));//申请结点的内存if(!Q.front) //判断有无申请到空间return ERROR; //没有返回0Q.front ->next = NULL;return OK;}8.在队列队尾插入元素/* 函数功能：在队列队尾插入元素参数：队列（LinkQueue &Q），插入元素e成功返回1，否则返回0 */ int EnQueue(LinkQueue &Q, QElemType e){p = (QueuePtr)malloc(sizeof(QNode)); //申请新的结点if(!p)return ERROR;p -> data = e;p -> next = NULL;Q.rear -> next = P;Q.rear = p;return OK;}9.删除队头元素/* 函数功能：删除对头元素参数：队列（LinkQueue &Q），记录值e成功返回1，否则返回0 */ int DeQueue(LinkQueue &Q, QElemType &e){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;}10、主函数int main(){SqStack S; //声明一个栈LinkQueue Q; //声明一个队列char m,k,c;int n=0,i,j,t=0,z=0;while(!t){cout << "请输入你要判断回文的字符串，输入@结束：";InitQueue (Q);InitStack (S);while((c=getchar())!='@')//对字符的判断不断输入字符{EnQueue (Q,c);Push (S,c);n++;}for( j=1;j<=n;j++){OutQueue (Q,m);Pop (S,k);if(m!=k)break;}if(j>n) //如果j > n则说明全部相等cout << "这个字符串不是回文字符串" << endl;elsecout << "这个字符串是回文字符串" << endl;}return 0;}说明：通过调用序列号不同的函数进行各种操作。
数据结构实验二
数据结构实验二数据结构实验二：队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构，加深对队列和栈实现原理的理解，并熟练掌握队列和栈的基本操作。
二、实验要求1.使用C/C++语言实现队列的基本操作：初始化队列、入队、出队、判空、判满等。
2.使用C/C++语言实现栈的基本操作：初始化栈、入栈、出栈、判空、判满等。
3.验证队列和栈的实现是否正确。
4.分析队列和栈的时间复杂度，并给出实验结果。
5.撰写实验报告，包括实验目的、实验原理、实验步骤、程序源代码、实验结果和分析、实验总结等内容。
三、实验原理1.队列：队列是一种先进先出(FIF0)的数据结构。
在队列中，数据元素按照进入队列的顺序排列，首元素是最先进入的元素，尾元素是最后进入的元素。
队列的基本操作有：初始化队列、入队、出队、判空、判满等。
2.栈：栈是一种后进先出(LIFO)的数据结构。
在栈中，数据元素按照进入栈的顺序排列，但是只能从栈顶进出，即最后进入的元素最先出栈。
栈的基本操作有：初始化栈、入栈、出栈、判空、判满等。
四、实验步骤1.实现队列的基本操作：1.初始化队列：创建一个空队列，并设置相关指针。
2.入队：将新元素插入到队尾。
3.出队：将队头元素删除，并返回其值。
4.判空：判断队列是否为空。
5.判满：判断队列是否已满。
2.实现栈的基本操作：1.初始化栈：创建一个空栈，并设置相关指针。
2.入栈：将新元素压入栈顶。
3.出栈：将栈顶元素弹出，并返回其值。
4.判空：判断栈是否为空。
5.判满：判断栈是否已满。
3.编写测试代码，验证队列和栈的基本操作是否正确。
4.进行性能测试，分析队列和栈的时间复杂度。
五、实验结果与分析1.队列的时间复杂度：●初始化队列：O(1)●入队：O(1)●出队：O(1)●判空：O(1)●判满：O(1)2.栈的时间复杂度：●初始化栈：O(1)●入栈：O(1)●出栈：O(1)●判空：O(1)●判满：O(1)3.根据实验结果可以看出，队列和栈的基本操作的时间复杂度都是O(1)，即常数时间复杂度，具有高效性。
数据结构实验2——栈和队列实验报告
数据结构实验报告实验名称：实验2——栈和队列1 实验目的通过选择下面五个题目之一进行实现，掌握如下内容：进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力2 实验内容利用栈结构实现八皇后问题。
八皇后问题19世纪著名的数学家高斯于1850年提出的。
他的问题是：在8*8的棋盘上放置8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列、同一斜线上。
请设计算法打印所有可能的摆放方法。
提示：1、可以使用递归或非递归两种方法实现2、实现一个关键算法：判断任意两个皇后是否在同一行、同一列和同一斜线上2. 程序分析主程序：#include<iostream>using namespace std;const int StackSize=8; //皇后的个数int num=0;template <class T>class SeqStack //定义顺序栈模板类{public:SeqStack(){top=-1;} //构造函数，初始化空栈void Push(T x); //入栈操作void Pop();//出栈操作void PlaceQueen(int row); //放置皇后bool Judgement();//判断是否符合条件void Print();//输出符合条件的皇后排列bool Empty(){if(top==-1) return true;else return false;}; //判断栈是否为空private:T data[StackSize]; //定义数组int top; //栈顶指针};template <class T>void SeqStack<T>::Push(T x) //入栈操作{if(top>=StackSize-1) throw"上溢";top++;//栈顶指针上移data[top]=x;}template <class T>void SeqStack<T>::Pop()//出栈操作{if(Empty()) throw"下溢";top--;//栈顶指针下移}template <class T>bool SeqStack<T>::Judgement()//判断该位置是否合适{for(int i=0;i<top;i++)if(data[top]==data[i]||(abs(data[top]-data[i]))==(top-i))//判断是否满足任意两个皇后不在同列同一斜线return false;return true;}template <class T>void SeqStack<T>::PlaceQueen(int row) //放置皇后{for (int i=0;i<StackSize;i++){Push(i); //入栈if (Judgement())//判断位置是否合适{if (row<StackSize-1)PlaceQueen(row+1); //如果合适满足条件则放置一个皇后,递归调用else{num++;//不满足条件则到下一行Print();//输出符合条件的皇后}}Pop();//出栈}}template <class T>void SeqStack<T>::Print()//输出皇后函数{cout<<"NO."<<num<<":"<<endl; for(int i=0;i<StackSize;i++){for(int j=0;j<data[i];j++){cout<<"□";}cout<<"■";for(int j=StackSize-1;j>data[i];j--){cout<<"□";}cout<<endl;}cout<<endl;}void main(){SeqStack<int> Queen;Queen.PlaceQueen(0);cout<<"总共有"<<num<<"种摆放方法。
《数据结构 (c语言版)》实验二 栈和队列
（2）一个程序中如果要用到两个栈时，可通过两个栈共享一维数组来实现。即双向栈共享邻接空间。如果一个程序中要用到两个队列，能否实现？如何实现？
六、实验报告
1.程序要添加适当的注释，程序的书写要采用缩进格式。
2.程序要具在一定的健壮性，即当输入数据非法时，程序也能适当地做出反应，如插入删除时指定的位置不对等等。
case 1:
StackDisplay(St);
break;
case 2:
printf("请输入要入栈的元素(一个整数):");
scanf("%d",&e); //输入要入栈的元素
temp=Push(St,e); //入栈
if(temp!=OK) printf("堆栈已满!入栈失败!\n");
else {
（一）实验内容
1.编写一个程序实现顺序栈的各种基本运算。
2.实现队列的链式表示和实现。
（二）实验步骤
1.初始化顺序栈
2.插入元素
3.删除栈顶元素
4.取栈顶元素
5.遍历顺序栈
6.置空顺序栈
7.初始化并建立链队列
8.入链队列
9.出链队列
10.遍历链队列
（三）实验提示
1./*定义顺序栈的存储结构*/
typedef struct {
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
* S.top ++ = e;
return OK;
}//Push
数据结构栈和队列实验报告
数据结构栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的栈和队列的基本概念、操作原理以及实际应用。
通过编程实现栈和队列的相关操作，加深对其特性的认识，并能够运用栈和队列解决实际问题。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理（一）栈栈（Stack）是一种特殊的线性表，其操作遵循“后进先出”（Last In First Out，LIFO）的原则。
可以将栈想象成一个只有一端开口的容器，元素只能从开口端进出。
入栈操作（Push）将元素添加到栈顶，出栈操作（Pop）则从栈顶移除元素。
（二）队列队列（Queue）也是一种线性表，但其操作遵循“先进先出”（FirstIn First Out，FIFO）的原则。
队列就像是排队买票的队伍，先到的人先接受服务。
入队操作（Enqueue）将元素添加到队列的末尾，出队操作（Dequeue）则从队列的头部移除元素。
四、实验内容（一）栈的实现与操作1、定义一个栈的数据结构，包含栈顶指针、存储元素的数组以及栈的最大容量等成员变量。
2、实现入栈（Push）操作，当栈未满时，将元素添加到栈顶，并更新栈顶指针。
3、实现出栈（Pop）操作，当栈不为空时，取出栈顶元素，并更新栈顶指针。
4、实现获取栈顶元素（Top）操作，返回栈顶元素但不进行出栈操作。
5、实现判断栈是否为空（IsEmpty）和判断栈是否已满（IsFull）的操作。
（二）队列的实现与操作1、定义一个队列的数据结构，包含队头指针、队尾指针、存储元素的数组以及队列的最大容量等成员变量。
2、实现入队（Enqueue）操作，当队列未满时，将元素添加到队尾，并更新队尾指针。
3、实现出队（Dequeue）操作，当队列不为空时，取出队头元素，并更新队头指针。
4、实现获取队头元素（Front）操作，返回队头元素但不进行出队操作。
5、实现判断队列是否为空（IsEmpty）和判断队列是否已满（IsFull）的操作。
数据结构栈和队列实验报告
数据结构栈和队列实验报告数据结构栈和队列实验报告1.引言本实验旨在通过设计和实现栈和队列的数据结构，掌握栈和队列的基本操作，并进一步加深对数据结构的理解和应用。
2.实验目的本实验的主要目标包括：________●掌握栈和队列的数据结构实现。
●熟悉栈和队列的基本操作：________入栈、出栈、入队、出队。
●理解栈和队列的应用场景，并能够灵活运用。
3.实验原理3.1 栈栈是一种特殊的数据结构，它采用“后进先出”的方式对元素进行操作。
栈的主要操作包括入栈和出栈，入栈将元素压入栈顶，出栈将栈顶元素弹出。
3.2 队列队列也是一种特殊的数据结构，它采用“先进先出”的方式对元素进行操作。
队列的主要操作包括入队和出队，入队将元素放入队列尾部，出队将队列头部的元素移除。
4.实验过程4.1 栈的实现a. 定义栈的数据结构在实现栈之前，首先要定义栈的数据结构，包括数据存储结构和相关操作方法。
b. 定义入栈操作入栈操作将元素压入栈顶。
c. 定义出栈操作出栈操作将栈顶元素弹出。
4.2 队列的实现a. 定义队列的数据结构在实现队列之前，首先要定义队列的数据结构，包括数据存储结构和相关操作方法。
b. 定义入队操作入队操作将元素放入队列尾部。
c. 定义出队操作出队操作将队列头部的元素移除。
5.实验结果与分析将栈和队列的数据结构实现后，可以进行测试和验证。
通过将不同类型的元素入栈和入队，然后再进行出栈和出队操作，最后检查栈和队列的状态，验证其正确性。
6.实验总结本实验通过设计和实现栈和队列的数据结构，掌握了栈和队列的基本操作。
并通过对栈和队列的应用，加深了对数据结构的理解和应用。
附件：________无法律名词及注释：________无。
数据结构实验报告 栈和队列
2007级数据结构实验报告实验名称：实验二栈和队列日期：2008年11月15日1．实验要求实验目的通过选择下面五个题目之一进行实现，掌握如下内容：进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力实验内容2.1题目1根据栈和队列的抽象数据类型的定义，按要求实现一个栈或一个队列。
要求：1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构存储结构：特殊线性表：栈，队列栈顶 栈底 链栈2.2 关键算法分析共享栈的入栈算法伪码（Push ）： 1．如果栈满，抛出上溢异常。
2．判断是插在栈1还是栈2：2.1如果在栈1插入，则栈顶指针top1加1，在top1处填入元素x ； 2.2如果在栈2插入，则栈顶指针top2加1，在top2处填入元素x 。
共享栈的出栈算法伪码（Pop ）：1. 判断是在栈1删除还是在栈2删除。
2. 若是在栈1删除，则2.1 若栈1为空栈，抛出下溢异常； 2.2 删除并返回栈1的栈顶元素；3. 若是在栈2删除，则3.1 若栈2为空栈，抛出下溢异常； 3.2 删除并返回栈2的栈顶元素。
非空链队列 空链队列共享栈的取栈顶元素算法伪码（GetTop）：1．判断是在栈1取还是栈2取；2．如果在栈1取，则2.1 若栈1不空，返回栈顶元素的值，不删除；2.2 若栈1空，返回0；3．如果在栈2取，则3.1 若栈2不空，返回栈顶元素的值，不删除；3.2 若栈2空，返回0。
链栈的入栈算法伪码（Push）：1．申请一个新的结点，数据域为x；2．将新结点插在栈顶；3．栈顶指针重新指向栈顶元素。
链栈的出栈算法伪码（Pop）：1．如果栈空，抛出下溢异常；2．暂存栈顶元素；3．将栈顶结点摘链；4．删除该结点，返回该元素的值。
链栈的取栈顶元素算法的伪码（GetTop）：1．如果栈非空，返回栈顶元素的值，不删除。
数据结构实验——栈和队列
2008级数据结构实验报告实验名称：实验二——栈和队列学生姓名：班级：班内序号：学号：日期：2009年11月7日1．实验要求根据栈和队列的抽象数据类型的定义，按要求实现一个栈或一个队列。
要求：1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构2.1.1共享栈2.1.2链栈2.2 关键算法分析2.2.1共享栈开辟一个空间，两个栈共享。
top1和top2分别为栈1和栈2的栈顶指针。
Stack_Size为整个数组空间的大小；栈1的底固定在下标为0的一端；栈2的底固定在下标为StackSize-1的一端。
如果是压栈，则栈1的top1加1，栈2的top2减1；如果是出栈，则栈1的top1减1，栈2的top2加1。
压栈： 1、如果栈满，则抛出上溢异常；2、判断是插在栈1还是栈2；2.1 若是在栈1插入，则栈顶指针top1加1，在top1处填入x；2.1 若是在栈2插入，则栈顶指针top2减1，在top2处填入x；时间复杂度为O（1）出栈：1、判断是在栈1删除还是在栈2删除。
2、若是在栈1删除，则2.1 若栈1为空栈，抛出下溢异常；2.2 删除并返回栈1的栈顶元素；3、若是在栈2删除，则3.1 若栈2为空栈，抛出下溢异常；3.2 删除并返回栈2的栈顶元素；时间复杂度为O（1）2.2.2链栈链栈在压栈的时候先创造一个新的结点，将要加入的元素作为它的元素。
将top->next 指向这个新的结点。
top指向这个新的结点。
在出栈的时候，先构造一个工作节点，把当前的栈顶结点赋给它。
将栈顶结点摘链，并释放工作结点。
压栈：1、工作指针p初始化；2、生成一个元素值为x的新结点；3、将新结点s插入到结点p之后；时间复杂度为O（1）出栈：1、判断链栈是否为空；2、工作指针初始化；3、x暂存被删元素值；4、top下移；5、释放工作指针；时间复杂度为O（1）3.程序运行结果3.1共享栈链栈：4. 总结1、通过实验知道了，如果时两个数据类型相同的栈，可以公用一个数组来节约内存空间。
数据结构栈和队列实验报告
数据结构栈和队列实验报告实验目的：掌握数据结构栈和队列的基本概念和操作，通过实验加深对栈和队列的理解。
1.实验原理1.1 栈的原理栈是一种具有后进先出(LIFO)特点的数据结构。
在栈中，只允许在栈顶进行插入、删除和访问操作，并且这些操作仅限于栈顶元素。
1.2 队列的原理队列是一种具有先进先出(FIFO)特点的数据结构。
在队列中，元素的插入操作只能在队列的一端进行，称为队尾。
而元素的删除操作只能在队列的另一端进行，称为队头。
2.实验要求2.1 实现栈和队列的基本操作●栈的基本操作：压栈、弹栈、获取栈顶元素和判断栈是否为空。
●队列的基本操作：入队、出队、获取队头元素和判断队列是否为空。
2.2 进行相应操作的测试●对栈进行插入、删除、访问等操作的测试，并输出测试结果。
●对队列进行插入、删除、访问等操作的测试，并输出测试结果。
3.实验环境●操作系统：Windows 10●开发工具：C++编译器4.实验步骤4.1 栈的实现步骤1：定义栈的结构体，包含栈的容量和栈顶指针。
步骤2：根据栈的容量动态分配内存。
步骤3：实现栈的基本操作函数：压栈、弹栈、获取栈顶元素和判断栈是否为空。
步骤4：进行栈的相关测试。
4.2 队列的实现步骤1：定义队列的结构体，包含队列的容量、队头和队尾指针。
步骤2：根据队列的容量动态分配内存。
步骤3：实现队列的基本操作函数：入队、出队、获取队头元素和判断队列是否为空。
步骤4：进行队列的相关测试。
5.实验结果与分析5.1 栈的测试结果●压栈操作测试：将若干元素压入栈中。
●弹栈操作测试：依次弹出栈中的元素。
●获取栈顶元素测试：输出栈顶元素。
●判断栈是否为空测试：输出栈是否为空的结果。
5.2 队列的测试结果●入队操作测试：将若干元素入队。
●出队操作测试：依次出队元素。
●获取队头元素测试：输出队头元素。
●判断队列是否为空测试：输出队列是否为空的结果。
6.结论通过本次实验，我们掌握了栈和队列的基本概念和操作。
数据结构栈和队列实验报告简版
数据结构栈和队列实验报告数据结构栈和队列实验报告1. 实验目的本实验的主要目的是通过实践的方式理解并掌握数据结构中栈和队列的概念、特点和基本操作。
通过实验，我们可以加深对栈和队列的理解，掌握栈和队列的应用方法，并能够设计和实现基于栈和队列的算法。
2. 实验内容本实验分为两个部分：栈的应用和队列的应用。
2.1 栈的应用栈是一种具有特定限制的线性表，它只允许在表的一端进行插入和删除操作，该端被称为栈顶。
栈的特点是“后进先出”（Last In First Out, LIFO），即最后进栈的元素最先出栈。
在本实验中，我们将实现一个简单的栈类，并应用栈来解决一个问题。
假设有一个字符串，其中包含了括号（圆括号、方括号和花括号），我们需要判断该字符串中的括号是否匹配。
为了达到这个目的，我们可以使用栈来辅助实现。
在实现过程中，我们可以定义一个栈来存储左括号，然后依次遍历字符串的每个字符。
当遇到左括号时，将其入栈；当遇到右括号时，判断栈顶是否是对应的左括号，如果是，则将栈顶元素出栈，否则说明括号不匹配。
最后，当栈为空时，表明所有的括号都匹配，否则说明括号不匹配。
2.2 队列的应用队列是一种具有特定限制的线性表，它只允许在表的一端进行插入操作（队尾），在表的另一端进行删除操作（队头）。
队列的特点是“先进先出”（First In First Out, FIFO），即最早进队列的元素最先出队列。
在本实验中，我们将实现一个简单的队列类，并应用队列来解决一个问题。
假设有一群人在排队等候，我们需要按照一定规则进行排队并输出结果。
为了达到这个目的，我们可以使用队列来进行模拟。
在实现过程中，我们可以定义一个队列来存储等候的人，然后依次将人入队列。
当需要输出结果时，我们可以通过队列的出队列操作，按照先后顺序依次输出到达队头的人。
通过使用队列，我们可以模拟人们排队等候的实际情况，并能够按照一定规则输出结果。
3. 实验过程本实验的实验过程如下：1. 首先，我们需要实现一个栈类。
数据结构栈和队列实验报告
数据结构栈和队列实验报告数据结构栈和队列实验报告引言：数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便于程序的运行和管理。
栈和队列是数据结构中最基本的两种形式之一，它们在实际应用中有着广泛的应用。
本实验旨在通过实际操作和观察，深入理解栈和队列的特性和应用。
一、实验目的：1. 了解栈和队列的基本概念和特性；2. 掌握栈和队列的基本操作；3. 理解栈和队列在实际应用中的作用。
二、实验过程：本次实验我们使用Python语言来实现栈和队列的操作。
首先，我们定义了栈和队列的类，并编写了相应的操作方法。
1. 栈的实现：栈是一种后进先出（LIFO）的数据结构，类似于我们日常生活中的弹簧簿记本。
我们首先定义了一个栈类，其中包括了栈的初始化、入栈、出栈、获取栈顶元素等方法。
通过这些方法，我们可以对栈进行各种操作。
2. 队列的实现：队列是一种先进先出（FIFO）的数据结构，类似于我们日常生活中的排队。
我们同样定义了一个队列类，其中包括了队列的初始化、入队、出队、获取队首元素等方法。
通过这些方法，我们可以对队列进行各种操作。
三、实验结果：我们通过实验，成功实现了栈和队列的基本操作。
在测试过程中，我们发现栈和队列在实际应用中有着广泛的用途。
1. 栈的应用：栈在计算机系统中有着重要的作用，例如在函数调用中，每次函数调用时都会将返回地址和局部变量等信息存储在栈中，以便于函数执行完毕后能够正确返回。
此外，栈还可以用于表达式求值、括号匹配等场景。
2. 队列的应用：队列在操作系统中常用于进程调度，通过维护一个就绪队列，操作系统可以按照一定的策略选择下一个要执行的进程。
此外，队列还可以用于消息传递、缓冲区管理等场景。
四、实验总结：通过本次实验，我们深入了解了栈和队列的特性和应用。
栈和队列作为数据结构中最基本的两种形式，它们在计算机科学中有着广泛的应用。
在实际编程中，我们可以根据具体的需求选择合适的数据结构，以提高程序的效率和可读性。
数据结构-堆栈和队列实验报告
数据结构-堆栈和队列实验报告数据结构堆栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的堆栈和队列的基本概念、操作原理以及实际应用。
通过实际编程实现堆栈和队列的相关操作，加深对其特性的认识，提高编程能力和解决问题的能力。
二、实验环境本次实验使用的编程语言为 Python，开发工具为 PyCharm。
三、实验原理（一）堆栈（Stack）堆栈是一种特殊的线性表，其操作遵循“后进先出”（Last In First Out，LIFO）的原则。
可以将堆栈想象成一个只能从一端进行操作的容器，新元素总是被添加到这一端（称为栈顶），而取出元素也只能从栈顶进行。
堆栈的基本操作包括：1、｀push`：将元素压入堆栈。
2、｀pop`：弹出堆栈顶部的元素。
3、｀peek`：查看堆栈顶部的元素，但不弹出。
（二）队列（Queue）队列是另一种特殊的线性表，其操作遵循“先进先出”（First In First Out，FIFO）的原则。
可以将队列想象成一个排队的队伍，新元素在队尾加入，而取出元素从队首进行。
队列的基本操作包括：1、｀enqueue`：将元素加入队列的尾部。
2、｀dequeue`：取出并删除队列头部的元素。
3、｀front`：查看队列头部的元素，但不取出。
四、实验内容（一）堆栈的实现｀｀｀pythonclass Stack:def ＿_init__(self)：selfitems ＝def push(self, item)：selfitemsappend(item)def pop(self)：if not selfis_empty(）：return selfitemspop(）else:return ＂Stack is empty" def peek(self)：if not selfis_empty(）：return selfitems-1else:return ＂Stack is empty" def is_empty(self)：return len(selfitems) ＝＝ 0 def size(self)：return len(selfitems)｀｀｀（二）队列的实现｀｀｀pythonclass Queue:def ＿_init__(self)：selfitems ＝def enqueue(self, item)：selfitemsappend(item)def dequeue(self)：if not selfis_empty(）：return selfitemspop(0) else:return ＂Queue is empty" def front(self)：if not selfis_empty(）：return selfitems0else:return ＂Queue is empty" def is_empty(self)：return len(selfitems) ＝＝ 0 def size(self)：return len(selfitems)｀｀｀（三）应用实例1、利用堆栈实现括号匹配的验证｀｀｀pythondef is_balanced_parentheses(exp)：stack ＝ Stack(）for char in exp:if char in ＇（｛＇：stackpush(char)elif char in ＇）｝＇：if stackis_empty(）：return Falsetop ＝ stackpop(）if （char ＝＝＇）＇ and top!＝＇（＇） or （char ＝＝＇｝＇ and top!＝＇｛＇） or （char ＝＝＇＇ and top!＝＇＇）：return Falsereturn stackis_empty(）｀｀｀2、利用队列实现打印杨辉三角的前 n 行｀｀｀pythondef print_yanghui_triangle(n)：queue ＝ Queue(）queueenqueue(1)print(1)for i in range(1, n)：prev_row ＝for ＿ in range(i ＋ 1)：num ＝ queuedequeue(）prev_rowappend(num)print(num, end=＂＂）if ＿＜ i:new_num ＝ prev_row_ ＋（prev_row_ 1 if ＿＞ 0 else 0) queueenqueue(new_num)print(）｀｀｀五、实验结果与分析（一）堆栈实验结果对于括号匹配的验证，输入`＂（（（）））＂｀，输出为`True`，表示括号匹配正确；输入`＂（（（））＂｀，输出为`False`，表示括号匹配错误。
2数据结构实验报告二栈和队列及其应用
文档根源为 :从网络采集整理.word 版本可编写 .支持.实验二栈和行列及其应用一、实验目的1.掌握栈和行列这两种抽象数据种类的特色，并能在相应的应用问题中正确采用它们。
2.娴熟掌握栈种类的两种实现方法。
3.娴熟掌握循环行列和链行列的基本操作实现算法。
二、实验内容用行列求解迷宫问题[ 问题描绘 ]以一个 M*N的长方阵表示迷宫， 0 和 1 分别表示迷宫中的通路和墙壁。
设计一个程序，对随意设定的迷宫，求出一条从进口到出口的通路，或得出没有通路的结论。
[ 基本要求 ]实现一个以次序储存构造的行列种类，而后编写一个求解迷宫的非递归途序。
求得的通路以三元组（ i ，j ，pre）的形式输出，此中：（ i， j）指示迷宫中的一个坐标，pre 表示本路径中上一个方块在行列中的下标。
[ 测试数据 ]由学生随意指定。
三、源代码# include <stdio.h>#define M 5// 行数#define N 5// 列数#define MaxSize 100// 队最多元素个数int mg[M+2][N+2]={// 一个迷宫 , 其周围要加上均为 1 的外框 {1,1, {1,1,1,1,1,1,1},{1,0,0,0,0,0,1},{1,0,1,0,0,1,1},文档根源为 :从网络采集整理.word 版本可编写 .支持.{1,0,1,0,0,1,1},{1,0,1,0,1,0,1},{1,0,0,0,0,0,1},{1,1,1,1,1,1,1}};typedef struct{int i,j;int pre;}Box;typedef struct{Box data[MaxSize];int front, rear;}QuType;void mgpath1(int xi,int yi,int xe,int ye) // 搜寻路径为：（ xi ，yi ） ->(xe,ye){void print (QuType qu, int front );int i,j,find=0,di;QuType qu;//定义次序队qu.front=qu.rear=-1;qu.rear++;qu.data[qu.rear].i=xi; //(xi,yi)进队qu.data[qu.rear].j=yi;qu.data[qu.rear].pre=-1;mg[xi][yi]=-1;while(qu.front!=qu.rear&&!find){qu.front++;i=qu.data[qu.front].i;j=qu.data[qu.front].j;if(i==xe&&j==ye){find=1;print(qu,qu.front);}for(di=0;di<4;di++){switch(di){case0:i=qu.data[qu.front].i-1;j=qu.data[qu.front].j;break;case1:i=qu.data[qu.front].i;j=qu.data[qu.front].j+1;break;case2:i=qu.data[qu.front].i+1;j=qu.data[qu.front].j+1;break;case3:i=qu.data[qu.front].i;j=qu.data[qu.front].j-1;break;}if(mg[i][j]==0){find=1;qu.rear++;qu.data[qu.rear].i=i; qu.data[qu.rear].j=j;qu.data[qu.rear].pre=qu.front;mg[i][j]=-1;}}}}void print (QuType qu, int front ){int k=front,j,ns=0;printf("\n");do{j=k;k=qu.data[k].pre;qu.data[j].pre=-1;}while (k!=0);printf(" 迷宫路径以下： \n");k=0;while(k<MaxSize){if(qu.data[k].pre==-1){ns++;printf("\t(%d,%d)",qu.data[k].i,qu.data[k].j);if(ns%5==0)printf("\n");}k++;}printf("\n");}void main(){ mgpath1(1,1,M,N);printf("迷宫全部路径以下 :\n");}四、测试结果：五、心得领会做实验第一要掌握大批的理论知识，而后仔细去达成实验。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》实验指导及报告书 2014 / 2015 学年第 1学期姓名：学号：班级：指导教师：***计算机科学与工程学院2014实验二栈和队列一、实验目的1、掌握栈的结构特性及其入栈，出栈操作；2、掌握队列的结构特性及其入队、出队的操作，掌握循环队列的特点及其操作。
二、实验内容和要求1、阅读下面程序，将函数Push和函数Pop补充完整。
要求输入元素序列1 2 3 4 5 e，运行结果如下所示。
#include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define STACK_INT_SIZE 10 /*存储空间初始分配量*/#define STACKINCREMENT 5 /*存储空间分配增量*/typedef int ElemType; /*定义元素的类型*/typedef struct{ElemType *base;ElemType *top;int stacksize; /*当前已分配的存储空间*/}SqStack;int InitStack(SqStack *S); /*构造空栈*/int push(SqStack *S,ElemType *e); /*入栈*/int Pop(SqStack *S,ElemType *e); /*出栈*/int CreateStack(SqStack *S); /*创建栈*/void PrintStack(SqStack *S); /*出栈并输出栈中元素*/int InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base) return ERROR;S->top=S->base;S->stacksize=STACK_INT_SIZE;return OK;}/*InitStack*/int Push(SqStack *S,ElemType e){}/*Push*/int Pop(SqStack *S,ElemType *e){}/*Pop*/int CreateStack(SqStack *S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n"); while(scanf("%d",&e))Push(S,e);return OK;}/*CreateStack*/void PrintStack(SqStack *S){ElemType e;while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n1-createStack\n");CreateStack(&ss);printf("\n2-Pop&Print\n");PrintStack(&ss);return 0;}算法分析：输入元素序列1 2 3 4 5，为什么输出序列为5 4 3 2 1？体现了栈的什么特性？#include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define STACK_INT_SIZE 10 /*存储空间初始分配量*/#define STACKINCREMENT 5 /*存储空间分配增量*/typedef int ElemType; /*定义元素的类型*/typedef struct{ElemType *base;ElemType *top;int stacksize; /*当前已分配的存储空间*/}SqStack;int InitStack(SqStack *S); /*构造空栈*/int Push(SqStack *S,ElemType *e); /*入栈*/int Pop(SqStack *S,ElemType *e); /*出栈*/int CreateStack(SqStack *S); /*创建栈*/void PrintStack(SqStack *S); /*出栈并输出栈中元素*/int InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType));if(!S->base) return ERROR;S->top=S->base;S->stacksize=STACK_INT_SIZE;return OK;}/*InitStack*/int Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(Ele mType));if(!S->base) return ERROR;S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return OK;}/*Push*/int Pop(SqStack *S,ElemType *e){if(S->top=S->base)return ERROR;e= --S->top;return OK;int CreateStack(SqStack *S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n");while(scanf("%d",&e))Push(S,e);return OK;}/*CreateStack*/void PrintStack(SqStack *S){ElemType e;while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n1-createStack\n");CreateStack(&ss);printf("\n2-Pop&Print\n");Pop(&ss, &e);PrintStack(&ss);return 0;}2、在第1题的程序中，编写一个十进制转换为二进制的数制转换算法函数（要求利用栈来实现），并验证其正确性。
实现代码#include<stdio.h>#include<malloc.h>#define ERROR 0#define STACK_INIT_SIZE 10 /*存ä?储ä¡é空?间?初?始º?分¤?配?量¢?*/#define STACKINCREMENT 5 /*存ä?储ä¡é空?间?分¤?配?增?量¢?*/typedef int SElemType; /*定¡§义°?元a素?的Ì?类¤¨¤型¨ª*/typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int InitStack(SqStack &S);int CreateStack(SqStack *S);int GetTop(SqStack S,SElemType &e);int Push(SqStack &S,SElemType e);int Pop(SqStack &S,SElemType &e);void conversion();void main(){int e;SqStack S;CreateStack(S);GetTop( S, e);Push( S, e);conversion();}int InitStack(SqStack &S){S.base=(SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;}int CreateStack(SqStack &S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n");while(scanf("%d",&e))Push(S,e);return OK;}int GetTop(SqStack S,SElemType &e){if(S.top==S.base) return ERROR;e=*(S.top-1);return OK;}int 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)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}}int Pop(SqStack &S,SElemType &e){if(S.top==S.base)return ERROR;e= *--S.top;return OK;}void conversion(){int n,e;SqStack S;printf("input data:\n");scanf("%d",n);while(n){Push(S,n);n=n/2;}Pop(S,e);printf("%d",e);}3、阅读并运行程序，并分析程序功能。