下载文档原格式
数据结构实验指导书（C++）-栈、队列、串的操作实验二栈、队列、串的操作实验类型：验证性实验要求：必修实验学时： 2学时一、实验目的：参照给定的栈类和队列类的程序样例，验证给出的栈和队列的常见算法，并结合线性表类实现有关串的操作。
二、实验要求：1、掌握栈、队列、串的特点。
掌握特殊线性表的常见算法。
2、提交实验报告，报告内容包括：目的、要求、算法描述、程序结构、主要变量说明、程序清单、调试情况、设计技巧、心得体会。
三、实验内容：1. 堆栈类测试和应用问题。
要求：(1)设计一个主函数实现对顺序堆栈类和链式堆栈类代码进行测试。
测试方法为：依次把数据元素1,2,3,4,5入栈，然后出栈堆栈中的数据元素并在屏幕上显示。
(2)定义数据元素的数据类型为如下形式的结构体：typedef struct{ char taskname[10];//任务名int taskno; //任务号｝DataType；设计一个包含5个数据元素的测试数据，并设计一个主函数实现依次把5个数据元素入栈，然后出栈堆栈中的数据元素并在屏幕上显示。
2. 队列类测试和应用问题。
要求：设计一个主函数对循环队列类和链式队列类代码进行测试.测试方法为：依次把数据元素1,2,3,4,5入队，然后出队中的数据元素并在屏幕上显示。
3．设计串采用顺序存储结构，编写函数实现两个串的比较Compare(S, T)。
要求比较结果有大于、等于和小于三种情况。
*4. 设计算法利用栈类实现把十进制整数转换为二至九进制之间的任一进制输出。
*5. 设计串采用静态数组存储结构，编写函数实现串的替换Replace(S, start, T, V)，即要求在主串S中，从位置start开始查找是否存在子串T，若主串S中存在子串T，则用子串V替换子串T，且函数返回1；若主串S中不存在子串T，则函数返回０。
并要求设计主函数进行测试。
一个测试例子为：S＝”I am a student”，T=”student”，V=”teacher “。
实验报告05-链队列的基本操作实验目的及要求：了解和掌握链队列的特点；掌握链队列基本操作的实现；要求完成链队列的初始化、入队、出队、取队头元素、显示操作的实现。
实验设备环境及要求：PC机一台，内存要求128M以上，VC++6.0集成开发环境。
实验内容与步骤：1、在VC++6.0环境中新建一个工程和C++文件；2、实现链队列初始化、入队、出队、取队头元素算法，代码如下：#include#includetypedef char QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;int InitQueue(LinkQueue &Q){Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));if(!Q.front) return 0;Q.front->next = NULL;return 1;}int EnQueue(LinkQueue &Q,QElemType e){QueuePtr p;p = (QueuePtr) malloc(sizeof(QNode));if(!p) return 0;p->data = e;p->next = NULL;Q.rear->next = p;Q.rear = p;return 1;}int DeQueue(LinkQueue &Q,QElemType &e){ QueuePtr p;if(Q.front == Q.rear) return 0;p = Q.front->next;e = p->data;Q.front->next = p->next;if(Q.rear == p) Q.rear = Q.front;free(p);return 1;}int DestroyQueue(LinkQueue &Q){while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return 1;}void DispQueue(LinkQueue Q){QueuePtr p;if(Q.front == Q.rear) printf("队列为空！！\n"); for(p = Q.front->next; p; p = p->next)printf("%c",p->data);printf("\n");}void main(){LinkQueue Q;QElemType e;InitQueue(Q);EnQueue(Q,'A');EnQueue(Q,'B');EnQueue(Q,'C');EnQueue(Q,'D');EnQueue(Q,'E');printf("队列为:");DispQueue(Q);DeQueue(Q,e);printf("队头元素为：");printf("%c\n",e);printf("队列为:");DispQueue(Q);DestroyQueue(Q);}实验指导与数据处理：实验结果：队列为:ABCDE队头元素为：A队列为:BCDE分析讨论：本次实验通过对链队列基本操作的实现，加深了对链队列特点的理解，并且熟悉了VC++6.0集成环境，虽然在调试过程中遇到一些问题，但经分析后达到了预期的结果。
队列基本操作
队列是一种线性数据结构，它按照先进先出（FIFO）的原则存储和检索数据。
队列的基本操作包括：
入队（Enqueue）：将元素添加到队列的末尾，使其按照先进先出的顺序进行存储。
出队（Dequeue）：从队列的头部取出元素，并删除它，使其按照先进先出的顺序进行检索。
查看队头（Peek）：查看队列中第一个元素，但不删除它。
队列大小（Size）：获取队列中元素的数量。
队列是否为空（Empty）：判断队列中是否没有元素。
队列首尾指针（Front，Back）：分别指向队列的头部和尾部，其中Front表示队列的第一个元素的索引，Back表示队列的最后一个元素的索引。
队列队列长度（Queue）：获取队列中所有元素的数量。
队列是否满（Full）：判断队列中元素的数量是否达到了最大容量。
队列移动（Move）：将队列中的元素顺序进行移动。
队列重置（Reset）：将队列中的元素全部删除，使其变为空队列。
实验报告名称：
姓名：学号：专业班级：
日期：
实验4: 顺序循环队列基本操作一、实验目的
1．熟悉并能实现顺序循环队列的定义和基本操作。
2．了解用队列解决实际应用问题。
二、实验要求
1．进行队列的基本操作时要注意队列“先进先出”的特性。
2．复习关于栈操作的基础知识。
3．编写完整程序完成下面的实验内容并上机运行。
4．整理并上交实验报告。
三、实验内容
1．掌握队列的思想及其存储实现。
2．掌握队列的常见算法的程序实现：
(1.) 判断队列是否为空
(2.) 测试队列的长度
(3.) 取队头元素值
(4.) 向队列中插入一新元素
(5.) 删除队列中一元素
3．在主函数中设计一个简单的菜单，分别调试上述算法。
数据结构实验二数据结构实验二：队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构，加深对队列和栈实现原理的理解，并熟练掌握队列和栈的基本操作。
二、实验要求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.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．掌握队列的定义及实现；2．掌握利⽤队列的基本操作。
实验要求：1、使⽤链式结构完成队列的各种基本操作；2、补充完善教材81页的舞伴问题。
实验项⽬名称：队列的基本操作应⽤实验过程：1、先建⽴⼀个舞者队列，依次往队列中添加⼈员信息（8个⼈，5男3⼥）；2、分别创建男⼥队列；3、从舞者队列中依次将队⾸元素出队并判断其性别并添加⾄男队（5⼈）或⼥队（3⼈）；4、分别从男队和⼥队出队队⾸元素并配对输出；（男队⼥队分别3⼈）5、将未完成的⼀队队⾸元素输出（男队的队⾸成员名称）。
实验报告中给出算法3.23的代码实验结果：输⼊：8⼈信息（A,B,C,D,E,F,G,H）输出：The dancepartners:A---BC---DE---FG is waiting for a partner.实验分析：1.队列的操作特点；2.列举调试运⾏过程中出现的错误并分析原因。
要求：(1) 程序要添加适当的注释，程序的书写要采⽤缩进格式。
(2) 程序要具在⼀定的健壮性，即当输⼊数据⾮法时，程序也能适当地做出反应。
(3) 程序要做到界⾯友好，在程序运⾏时⽤户可以根据相应的提⽰信息进⾏操作。
(4) 上传源程序到课堂派。
顺序表的源程序保存为dancepartner.cpp。
程序代码：#include<stdio.h>#define MAXQSIZE 100#define QueueSize 20#define OK 1#define ERROR 0#define OVERFLOW 0#include <cstdlib>#include<iostream>using namespace std;typedef char QElemType;typedef int Status;//typedef char SElemType;typedef struct{char name[QueueSize];char sex;}person;typedef struct{person *dancer;person *base; //存储空间的基地址int front; //头指针int rear; //尾指针}SqQueue;Status InitQueue(SqQueue &Q){//构造⼀个空队列QQ.base=new person[MAXQSIZE]; //为队列分配⼀个最⼤容量为MAXQSIZE的数组空间if(!Q.base) exit(OVERFLOW); //存储分配失败Q.front=Q.rear=0; //头指针和尾指针为零，队列为空return OK;}Status EnQueue(SqQueue &Q,person e){//插⼊元素e为Q的新的队尾元素if((Q.rear+1)%MAXQSIZE==Q.front) //尾指针在循环意义上加1后等于头指针，表明队满return ERROR;Q.base[Q.rear]=e; //新元素插⼊队尾Q.rear=(Q.rear+1)%MAXQSIZE; //队尾指针加1return OK;}int QueueEmpty(SqQueue &Q){if (Q.front==Q.rear) return OK;else return ERROR;}Status DeQueue(SqQueue &Q,person &e){//删除Q的队头元素，⽤e返回其值if(Q.front==Q.rear) return ERROR; //队空e=Q.base[Q.front]; //保存队头元素Q.front=(Q.front+1)%MAXQSIZE; //队头指针加1return OK;}person GetHead(SqQueue Q){//返回Q的队列元素，不修改队头指针if(Q.front!=Q.rear) //队列⾮空return Q.base[Q.front]; //返回队头元素的值，队头指针不变}void DancePartner(person dancer[],int num){//结构数组dancer中存放跳舞的男⼥，num是跳舞的⼈数person p;int i;SqQueue Mdancers,Fdancers;InitQueue(Mdancers); //男⼠队列初始化InitQueue(Fdancers); //⼥⼠队列初始化for (i=0;i<num;i++) //根据性别依次将跳舞的⼈插⼊相应队列{p=dancer[i];if (p.sex=='F') EnQueue(Fdancers,p); //插⼊男队else EnQueue(Mdancers,p); //插⼊⼥队}cout<<"The dancing partner are:\n";while(!QueueEmpty(Fdancers)&&!QueueEmpty(Mdancers)){//依次输出男⼥舞伴的姓名DeQueue(Fdancers,p); //⼥⼠出队cout<<<<""; //输出出队⼥⼠姓名DeQueue(Mdancers,p); //男⼠出队cout<<<<endl; //输出出队男⼠姓名}if (!QueueEmpty(Fdancers)) //⼥⼠队⾮空，输出队头⼥⼠的姓名{p=GetHead(Fdancers); // 取⼥队的头cout<<<<" is waiting for a partner."<<endl;}else if (!QueueEmpty(Mdancers)) //男⼠队⾮空，输出男⼠队头的姓名 {p=GetHead(Mdancers); // 取男队的头cout<<<<" is waiting for a partner."<<endl;}}int main(){int i,j;person dancer[QueueSize];cout<<"请输⼊跳舞的⼈数：";cin>>j;while(j<=0){cout<<"输⼊错误，请重新输⼊跳舞的⼈数：";cin>>j;}for(i=1;i<=j;i++){cout<<"请输⼊第"<<i<<"舞者的名字:"<<endl;cin>>dancer[i-1].name;cout<<"请输⼊第"<<i<<"个⼈的性别(F/M):"<<endl;cin>>dancer[i-1].sex;while(dancer[i-1].sex!='F'&&dancer[i-1].sex!='M'){cout<<"*******输⼊错误，请重新输⼊：\n";cout<<dancer[i-1].sex;cout<<"请输⼊第"<<i<<"个⼈的性别(F/M):"<<endl;cin>>dancer[i-1].sex;break;}}DancePartner(dancer,j);}。
栈和队列基本操作实验报告实验二堆栈和队列基本操作的编程实现【实验目的】堆栈和队列基本操作的编程实现要求:堆栈和队列基本操作的编程实现(2学时，验证型)，掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。
也鼓励学生利用基本操作进行一些应用的程序设计。
【实验性质】验证性实验(学时数:2H)【实验内容】内容:把堆栈和队列的顺序存储(环队)和链表存储的数据进队、出队等运算其中一部分进行程序实现。
可以实验一的结果自己实现数据输入、数据显示的函数。
利用基本功能实现各类应用，如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。
【实验分析、说明过程】分析:进栈操作先创建一个以x为值的新结点p，其data域值为x则进栈操作步骤如下: 将新结点p的指针域指向原栈顶S(执行语句p->next=S)。
将栈顶S指向新结点p(执行语句S=p)。
注:进栈操作的?与?语句执行顺序不能颠倒，否则原S指针其后的链表将丢失。
出栈操作先将结点栈顶S数据域中的值赋给指针变量*x，则删除操作步骤如下: 结点p 指针域指向原栈顶S(执行语句p=S)。
栈顶S指向其的下一个结点(执行语句S=S->next)释放p结点空间(执行语句free(p))。
队列分析:用链式存储结构实现的队列称为链队列，一个链队列需要一个队头指针和一个队尾指针才能唯一确定。
队列中元素的结构和前面单链表中的结点的结构一样。
为了操作方便，在队头元素前附加一个头结点，队头指针就指向头结点。
【思考问题】1. 栈的顺序存储和链表存储的差异,答:栈的顺序存储有‘后进先出’的特点，最后进栈的元素必须最先出来，进出栈是有序的，在对编某些需要按顺序操作的程序有很大的作用。
链表存储:通过链表的存储可以实现链表中任意位置的插入元素，删除任意元素，可以实现无序进出。
2. 还会有数据移动吗,为什么,答:栈的顺序存储不会有数据移动，移动的只是指向该数据地址的指针。
《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的1、掌握栈的结构特性及其⼊栈，出栈操作；2、掌握队列的结构特性及其⼊队、出队的操作，掌握循环队列的特点及其操作。
⼆、实验预习说明以下概念1、顺序栈：2、链栈：3、循环队列：4、链队三、实验内容和要求1、阅读下⾯程序，将函数Push和函数Pop补充完整。
要求输⼊元素序列1 2 3 4 5 e，运⾏结果如下所⽰。
#include#include#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;int Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return 1}/*Push*/int Pop(SqStack *S,ElemType *e){if(S->top!=S->base){*e=*--S->top;return 1;}elsereturn 0;}/*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*/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？体现了栈的什么特性？2、在第1题的程序中，编写⼀个⼗进制转换为⼆进制的数制转换算法函数（要求利⽤栈来实现），并验证其正确性。
