数据结构第二次实验报告
数据结构第二次实验报告
2.巩固对这两种结构方法的掌握。 3.接触较复杂问题的递归算法设计。
签名 2014 年 评语与成绩：
பைடு நூலகம்
郑小玉 11 月
20
日
教师签名： 年
月
日
实验内容： （数制转换操作） int conversion(int N,int d) { //N:表示十进制正整数,d 表示 2 到 16 之间的某种进制 //面实现将十进制整数 N 转换成某种 d 进制数,并输出显示。 SqStack S; int e; InitStack(S);//构造空栈 while(N) { Push(S, N % d); N = N / d; } while(!StackEmpty(S)) { Pop(S,e); if(e<10) cout<<e; else cout<<e+55; } cout<<endl; }
数据结构实验2报告总结
一实验目的和要求理解二叉树的基本概念，熟练使用多种表示法构造二叉树，掌握采用二叉链表存储结构实现二叉树的构造、遍历、插入、删除等操作算法；理解线索二叉树的作用，掌握获得线索二叉树节点在指定遍历次序下的前驱或后继结点的方法；理解哈弗曼编码和哈弗曼树的作用，掌握由指定文本求得哈弗曼编码的方法。
理解树的基本概念，熟悉树的多种存储结构，掌握采用孩子兄弟链表存储结构实现树的遍历、插入、删除等操作算法。
通过研究树和二叉树，深刻理解链式存储结构用于表达非线性结构的作用，掌握采用递归算法实现递归数据结构基本操作的设计方法。
二题目及题意分析题目：插入x元素作为p结点的第i个孩子分析：以中国城市作为元素,以插入孩子结点的方式构造一棵树，找到结点p，p不为空时，若p的孩子结点为空，则直接插入x元素作为p的孩子;若p的孩子结点不为空，插入的x元素的位置n小于等于1时，将x元素直接插在最前面;若n大于1时，查找插入的位置执行插入。
三设计方案和功能说明源程序如下：TreeNode.htemplate<class T>class TreeNode //数的孩子兄弟链表结点类{public: //数据域，保存元素T data;TreeNode<T>* child,*sibling; //指针域，分别指向孩子兄弟结点TreeNode<T>(T data,TreeNode<T>*child=NULL,TreeNode<T>*sibling=NULL){this->data=data;this->child=child;this->sibling=sibling;}};Tree.h#include<iostream.h>#include"TreeNode.h" //树的孩子兄弟链表节点类template<class T>class Tree //树类{public:TreeNode<T>*root; //指向根结点Tree(); //构造空树bool isEmpty();//判断是否空树TreeNode<T>* insertChild(TreeNode<T>*p,T value); // 插入value作为结点p的孩子TreeNode<T>* insertChild(TreeNode<T>*p,T x,int i);// 插入x元素作为p结点的第i 个孩子friend ostream&operator<<(ostream&out,Tree<T>&tree);//先根次序遍历树并以树的横向凹入表示法输出树void preOrder(TreeNode<T> *p,int i);};template<class T>Tree<T>::Tree() //构造空树{root=NULL;}template<class T>bool Tree<T>::isEmpty()//判断是否空树{return root==NULL;}template<class T>TreeNode<T>* Tree<T>::insertChild(TreeNode<T>*p,T value) //插入value作为结点p的孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T> (value);if(p->child==NULL)p->child=q;else{p=p->child;while(p->sibling!=NULL)p=p->sibling;p->sibling=q;}}return q;}template<class T>TreeNode<T>*Tree<T>::insertChild(TreeNode<T>* p,T x,int i)// 插入x元素作为p结点的第i 个孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T>(x);if(p->child==NULL)p->child=q;else{{if(i<=1)//带有容错功能{p->child=new TreeNode<T>(x,NULL,p->child);return p->child;}p=p->child;for(int j=1;p->sibling!=NULL&&j<i-1;j++)p=p->sibling;if( p->sibling==NULL)p->sibling=q;elsep->sibling=new TreeNode<T>(x,NULL,p->sibling);}}}return q;}template<class T>void Tree<T>::preOrder(TreeNode<T> *p,int i){if(p!=NULL){for(int j=0;j<i;j++)cout<<"\t";cout<<p->data<<endl;preOrder(p->child,i+1);preOrder(p->sibling,i);}}template<class T>ostream&operator<<(ostream&out,Tree<T> &tree)//先根次序遍历树并以树的横向凹入表示法输出树{tree.preOrder(tree.root,0);return out;}Main.cpp#include "Tree.h"TreeNode<char*>*aa;void make(Tree<char*>&tree){tree.root=new TreeNode<char*>("中国");tree.insertChild(tree.root,"北京");tree.insertChild(tree.root,"上海");TreeNode<char*>*js=tree.insertChild(tree.root,"江苏省");tree.insertChild(js,"南京市");tree.insertChild(js,"苏州市");TreeNode<char*> *zj=tree.insertChild(tree.root,"浙江省");tree.insertChild(zj,"杭州市");tree.insertChild(zj,"宁波市");TreeNode<char*> *sx=tree.insertChild(tree.root,"山西省");tree.insertChild(sx,"太原市");tree.insertChild(sx,"大同市");aa=zj;}int main(){Tree<char*>tree;make(tree);cout<<tree;tree.insertChild(aa,"无锡市",2);cout<<tree;return 0;}四运行结果及分析1插入位置小于等于1（即n<=1）n=-2时n=0时n=1时2插入位置大于1（即n>1）n=2时五实验总结通过实验理解了树及二叉树的存储结构熟悉掌握了孩子兄弟链表的存储结构实现，以及遍历、查找、删除等操作，深刻理解实现链式存储结构表达非线性的树存储结构。
数据结构实验报告2
数据结构实验报告2数据结构实验报告21、实验目的本次实验的目的是通过使用数据结构来解决一个特定的问题。
具体而言，我们将会使用某种数据结构（例如链表、堆栈、队列等）来实现一个特定功能，并对其性能进行评估。
2、实验背景在本次实验中，我们将会探索数据结构在解决实际问题中的应用。
数据结构是计算机科学的重要组成部分，它提供了一种组织和管理数据的方式，以便能够高效地访问和操作这些数据。
3、实验内容在本次实验中，我们选择了一种经典的数据结构，以实现一个特定的功能。
具体而言，我们将会使用链表来实现一个简单的联系人管理系统。
3.1 数据结构选择我们选择了链表作为联系人管理系统的数据结构。
链表是一种灵活的数据结构，它能够动态地增加或删除元素，并且支持高效的插入和删除操作。
3.2 实现功能我们的联系人管理系统将会具有以下功能：- 添加联系人：用户可以输入联系人的姓名、方式号码等信息，并将其添加到联系人列表中。
- 删除联系人：用户可以选择要删除的联系人，并从列表中删除该联系人。
- 查找联系人：用户可以根据姓名或方式号码来查找联系人，并显示相关信息。
- 显示所有联系人：系统将会将所有联系人按照姓名的字母顺序进行排序，并将其显示在屏幕上。
4、实验步骤下面是本次实验的具体步骤：4.1 初始化联系人管理系统在系统开始之前，我们需要初始化联系人管理系统。
这包括创建一个空的联系人列表，并提供用户菜单来选择相应功能。
4.2 添加联系人用户可以选择添加联系人的功能，并输入联系人的相关信息。
系统将会将联系人添加到联系人列表中。
4.3 删除联系人用户可以选择删除联系人的功能，并输入要删除联系人的姓名或方式号码。
系统将会在联系人列表中查找并删除相应联系人。
4.4 查找联系人用户可以选择查找联系人的功能，并输入要查找联系人的姓名或方式号码。
系统将会在联系人列表中查找相应联系人，并显示其相关信息。
4.5 显示所有联系人用户可以选择显示所有联系人的功能。
数据结构实验报告2
数据结构实验报告2一、实验目的本次数据结构实验旨在通过实际操作和编程实践，深入理解和掌握常见的数据结构，如链表、栈、队列、树等，并能够运用所学知识解决实际问题，提高编程能力和算法设计能力。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容（一）链表的实现与操作1、单向链表的创建首先，定义了链表节点的结构体，包含数据域和指向下一个节点的指针域。
然后，通过函数实现了单向链表的创建，从用户输入获取节点的数据，依次创建新节点并连接起来。
2、链表的遍历编写函数实现对单向链表的遍历，依次输出每个节点的数据。
3、链表的插入与删除实现了在指定位置插入节点和删除指定节点的功能。
插入操作时，需要找到插入位置的前一个节点，修改指针完成插入。
删除操作时，同样找到要删除节点的前一个节点，修改指针并释放删除节点的内存。
（二）栈的实现与应用1、栈的基本操作使用数组实现了栈的数据结构，包括入栈、出栈、判断栈空和获取栈顶元素等操作。
2、表达式求值利用栈来实现表达式求值的功能。
将表达式中的数字和运算符分别入栈，按照运算规则进行计算。
（三）队列的实现与应用1、队列的基本操作使用循环数组实现了队列，包括入队、出队、判断队空和队满等操作。
2、模拟银行排队系统通过创建队列来模拟银行客户的排队情况，实现客户的入队和出队操作，统计平均等待时间等。
（四）二叉树的遍历1、二叉树的创建采用递归的方式创建二叉树，用户输入节点数据，构建二叉树的结构。
2、先序、中序和后序遍历分别实现了二叉树的先序遍历、中序遍历和后序遍历，并输出遍历结果。
四、实验结果与分析（一）链表实验结果成功创建、遍历、插入和删除单向链表。
通过对链表的操作，深入理解了链表的动态存储特性和指针的运用。
在插入和删除操作中，能够正确处理指针的修改和内存的释放，避免了内存泄漏和指针错误。
（二）栈实验结果栈的基本操作运行正常，能够正确实现入栈、出栈等功能。
数据结构实验二报告模板
数据结构实验2 回文判断班级：java092学号：200907092240姓名：赵冬冬实验一回文判断一、实验目的熟练栈和队列的各种操作。
二、实验内容1．同时建立一个栈和一个队列，即：每从键盘上输入一个字符，就把它作为一个新的栈和队列结点的数据域，插入到栈和队列。
这样就同时建立了一个栈和一个队列。
然后，让栈出栈的同时队列出队，比较它们是相等。
2．设计简单的程序实现回文判断的操作，加注释！//回文判断.cpp#include<stdio.h>#include<stdlib.h>typedef struct Node //定义队列结点类型{char data;struct Node *next;}Linkqueuenode;typedef struct {Linkqueuenode *front;//定义队列的对首指针Linkqueuenode *rear;//定义队列的对尾指针}Linkqueue;typedef struct node //定义栈结点类型{char data;struct node *next;}LinkStackNode,*LinkStack;void push( LinkStack top,char x) //进栈{LinkStackNode *temp; //创建新结点temp=(LinkStackNode *)malloc(sizeof(LinkStackNode));//分配空间temp->data=x;//接点赋值temp->next=top->next;top->next=temp;//数据进栈}void getinmain() //功能界面{printf("\t\t__________________________________________\n");printf("\t\t\t\t回文检测\t\t\n");printf("\n\n");printf("\t\t\t\t1. 输入字符串\n");printf("\t\t\t\t2. 检测是否为回文\n");printf("\t\t\t\t3. 退出\n");printf("\n请按指定的数字进行相应的操作:\n");}int queue(Linkqueue *q) //初始化队列{q->front=(Linkqueuenode *)malloc(sizeof(Linkqueuenode));//队列分配空间if(q->front!=NULL)//判断队是否为空{q->rear=q->front;//初始化队，使队为空q->front->next=NULL;return 1;}else return 0;}int enter(Linkqueue *q,char x) //入队操作{Linkqueuenode *newnode;//创建新结点newnode=(Linkqueuenode *)malloc(sizeof(Linkqueuenode));//队列分配空间if(newnode!=NULL){newnode->data=x;//结点赋值newnode->next=NULL;q->rear->next=newnode;//数据入队q->rear=newnode;return 1;}else return 0;}void pushenter(LinkStack top,Linkqueue *q) //一个元素同时进栈和入队{printf("请输入元素并以$结束\n");char x;//进栈和入队的元素scanf("%c",&x);while(x!='$')//输入$字符是停止循环{push(top,x);enter(q,x);scanf("%c",&x);//元素同时进栈和入队}printf("数据进栈入列成功！\n");}void check(LinkStack top,Linkqueue *p)//检测是否为回文数{char a,b;int c=0;Linkqueuenode *q;LinkStack w;w=top->next;q=p->front->next;while(q!=NULL&&w->next!=NULL)//判断队列和栈是否为空{a=w->data;//队列和栈不为空则进行出队和出栈操作b=q->next->data;q=q->next;w=w->next;printf("a=%c b=%c\n",a,b);if(a!=b)//检测是否为回文数{c=1;printf(">>>>>>>>>>>>>>>>不为回文<<<<<<<<<<<<<<<<<\n");break;}}if(c==0)printf("\n>>>>>>>>>>>>>>>>为回文<<<<<<<<<<<<<<<<<\n");}void main(){LinkStackNode top;//声明一个栈结点top.next=NULL;//将栈顶值为空Linkqueue q;queue(&q);//初始化队列system("pause");system("cls");s: getinmain();//进入功能选择界面int b;scanf("%d",&b);//选择功能switch(b){case 1:pushenter(&top,&q);system("pause");system("cls");goto s;case 2:check(&top,&q);system("pause");system("cls");goto s;case 3:exit(0);};}//实现各子函数并且加注释运行结果如下图：1、主菜单运行图2、输入数据2、检验是否为回文三、编程并上机调试运行四、时间、地点2011-4-8（星期五）软件学院机房五、指导教师邢莹（在书写过程中若出现错误，望老师指出，谢谢）。
2022年北工大数据结构第二次上机中缀转后缀实验报告
北京工业大学- 第学期信息学部计算机学院3月31日报告题目：输入中缀体现式，输出后缀体现式，并对体现式求值A．分析中缀体现式旳运算顺序受运算符优先级和括号旳影响。
因此，将中缀体现式转换成等价旳后缀体现式旳核心在于如何恰当旳去掉中缀体现式中旳括号，然后在必要时按照先乘除后加减旳优先规则调换运算符旳先后顺序。
在去括号旳过程中用栈来储存有关旳元素。
基本思路：从左至右顺序扫描中缀体现式，用栈来寄存体现式中旳操作数，开括号，以及在这个开括号背面旳其她临时不能拟定计算顺序旳内容。
（1）当输入旳是操作数时，直接输出到后缀体现式（2）当遇到开括号时，将其入栈（3）当输入遇到闭括号时，先判断栈与否为空，若为空，则表达括号不匹配，应作为错误异常解决，清栈退出。
若非空，则把栈中元素依次弹出，直到遇到第一种开括号为止，将弹出旳元素输出到后缀体现式序列中。
由于后缀体现式不需要括号，因此弹出旳括号不放到输出序列中，若没有遇到开括号，阐明括号不匹配，做异常解决，清栈退出。
（4）当输入为运算符时（四则运算+ - * / 之一）时：a.循环，当（栈非空&&栈顶不是开括号&&栈顶运算符旳优先级不低于输入旳运算符旳优先级）时，反复操作将栈顶元素弹出，放到后缀体现式中。
b.将输入旳运算符压入栈中。
（5）最后，当中缀体现式旳符号所有扫描完毕时，若栈内仍有元素，则将其所有依次弹出，放在后缀体现式序列旳尾部。
若在弹出旳元素中遇到开括号，则阐明括号不匹配，做异常解决，清栈退出。
B．实现#include<stdio.h>#include<string.h>#include<stdlib.h>#include<stack>using namespace std;#define N 1000char infix[N]; //中缀体现式（未分离，都在一种字符串里）char expression[N][10]; //保存预解决过旳体现式，也就是每个元素都分离过旳体现式char suffix[N][10]; //保存后缀体现式旳操作数int count;//体现式中元素旳个数（一种完整到数字（也许不止一位数）或者符号）int suffixLength;//后缀体现式旳长度int level(char a){switch(a){case '#':return 0;case '+':case '-':return 1;case '*':case '/':return 2;case '^':return 3;default:break;}return -1;}int isDigital(char x){if( (x>='0'&&x<='9') || (x>='A'&&x<='Z') || (x>='a'&&x<='z') || (x=='.') )return 1;return 0;}int isNumber(char *str){int i;for(i=0;str[i];i++){if(isDigital(str[i])==0)return 0;}return 1;}/*************************************预解决中缀体现式，把持续旳字符分离成不同旳元素，用字符串数组（expression[][]）保存，以便背面旳计算，由于这里考虑了运算数也许不全是个位数例如：（12+3）在解决成后缀体现式时，是123+，容易产生歧义（1+23 ? 12+3）*************************************/void pretreatment(char *str){int i,j,numberFlag;char temp[3];char number[10];count=0;numberFlag=0;for(j=0,i=0;str[i];i++){if(isDigital(str[i])==0){if(numberFlag==1){number[j]=0;strcpy(expression[count++],number); j=0;numberFlag=0;}if(str[i]!=' '){temp[0]=str[i];temp[1]=0;strcpy(expression[count++],temp); }}else {numberFlag=1;number[j++]=str[i];}}puts("分离后旳体现式为");for(i=0;i<count;i++){printf("%s ",expression[i]);}puts("");puts("");}/*****************************************中缀体现式转后缀体现式遍历字符串，对于str[i]str[i]是运算数（或者是字母替代旳运算变量）输出；str[i]是符号，有两种状况(1)，是右括号，栈顶元素输出，直到与str[i]匹配旳左括号出栈（左括号不用输出打印）(2)，是运算符，判断str[i]与栈顶元素旳优先级，str[i]优先级不高于栈顶符号，则栈顶元素输出，直到栈空或者栈顶符号优先级低于str[i]*****************************************/void infix_to_suffix(char str[N][10]){memset(suffix,0,sizeof(suffix));suffixLength=0;stack <char*> st;int i=0;char Mark[2]="#";st.push(Mark);do{if(isNumber(str[i])==1)//运算数直接保存到后缀体现式中strcpy(suffix[suffixLength++],str[i]);else if(str[i][0]=='(') //是左括号，直接入栈st.push(str[i]);else if(str[i][0]==')'){ //是右括号，栈顶出栈，直到与其匹配旳左括号出栈while( strcmp(st.top(),"(")!=0 ){char temp[10];strcpy(temp,st.top());strcpy(suffix[suffixLength++],temp);st.pop();}st.pop();}else if( strcmp(st.top(),"(")==0 )//是运算符，且栈顶是左括号，则该运算符直接入栈st.push(str[i]);else { //是运算符，且栈顶元素优先级不不不小于运算符，则栈顶元素始终//出栈，直到栈空或者遇到一种优先级低于该运算符旳元素while( !st.empty() ){char temp[10];strcpy(temp,st.top());if( level(str[i][0]) > level(temp[0]) )break;strcpy(suffix[suffixLength++],temp);st.pop();}st.push(str[i]);}i++;}while(str[i][0]!=0);while( strcmp(st.top(),"#")!=0 ){ //将栈取空结束char temp[10];strcpy(temp,st.top());strcpy(suffix[suffixLength++],temp);st.pop();}puts("后缀体现式为：");for(i=0;i<suffixLength;i++){printf("%s",suffix[i]);}puts("");puts("");}/**************************************计算后缀体现式旳值**************************************/char kt[N][10];int stackTop;void getResult(char str[N][10]){stackTop=0;/*这里要注意，内存旳分派方案导致 i 旳位置就在temp[9]旁边，然后strcpy()函数直接拷贝内存旳话，在temp越界状况下会覆盖 i 旳值*/int i;char temp[10];for(i=0;i<suffixLength;i++){if(isNumber(str[i])==1){strcpy(kt[stackTop++],str[i]);}else {char a[10],b[10];double na,nb,nc;strcpy(a,kt[stackTop-1]);na = atof(a);stackTop--;strcpy(b,kt[stackTop-1]);nb = atof(b);stackTop--;if(str[i][0]=='+')nc=nb+na;else if(str[i][0]=='-')nc=nb-na;else if(str[i][0]=='*')nc=nb*na;else if(str[i][0]=='/')nc=nb/na;sprintf(temp,"%lf",nc);strcpy(kt[stackTop++],temp);}}puts("\nThe result is : %f\n");printf("%s\n",kt[stackTop-1]);}int main(){printf("Please input calculate Expression :\n"); char temp[N];while(gets(infix)){strcpy(temp,infix);pretreatment( strcat(temp," ") );infix_to_suffix(expression);getResult(suffix);}return 0;}C．总结实验需要细心细心再细心。
数据结构第二次
《数据结构》实验报告学生姓名学生班级学生学号指导老师一、实验内容单链表的建立、插入以及删除等基本操作二、需求分析（1）建立一个线性表；（2）依次输入数据元素1,2,3,4,5,6,7,8,9,10；（3）删除数据元素5；（4）依次显示当前线性表中的数据元素。
三、概要设计插入删除四、详细设计插入：if((q = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);q->data = x;q->next = p->next; /*给指针q->next赋值*/p->next = q; /*给指针p->next重新赋值*/ return 1;删除：while(p->next != NULL && p->next->next!= NULL && j < i - 1)/*最终让指针p指向数据元素ai-1结点*/{p = p->next;j++;}if(j != i - 1){printf("插入位置参数错！");return 0;}s = p->next; /*指针s指向数据元素ai结点*/*x = s->data; /*把指针s所指结点的数据元素域值赋予x*/p->next = s->next; /*把数据元素ai结点从单链表中删除指*/free(s); /*释放指针s所指结点的内存空间*/return 1;}输出结果五、遇到的问题及解决方法、在调试过程中不懂单链表的性质，经过查找书籍发现，要先交换指针。
六、心得体会通过这个实验课，让我了解了单链表的性质，以及单链表的删除以及插入。
更加深入理解指针。
数据结构实验二
数据结构实验二数据结构实验二：队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构，加深对队列和栈实现原理的理解，并熟练掌握队列和栈的基本操作。
二、实验要求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)，即常数时间复杂度，具有高效性。
数据结构第二章实验报告
数据结构第二章实验报告一、实验目的数据结构第二章主要涉及线性表的相关知识，本次实验的目的在于通过实际操作和编程实现，深入理解线性表的概念、存储结构以及基本操作，巩固所学的理论知识，并提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为C+＋，编程环境为Visual Studio 2019。
三、实验内容（一）顺序表的实现顺序表是一种用顺序存储方式实现的线性表。
在实验中，我们定义了一个结构体来表示顺序表，包括存储数据的数组和表示表长度的变量。
实现了顺序表的初始化、插入、删除、查找等基本操作。
（二）链表的实现链表是一种通过指针链接实现的线性表。
我们分别实现了单向链表和双向链表。
在单向链表中，每个节点包含数据和指向下一个节点的指针；双向链表则在此基础上增加了指向前一个节点的指针，使得链表的操作更加灵活。
（三）线性表的应用运用实现的线性表解决了一些实际问题，如数据排序、查找特定元素等。
四、实验步骤（一）顺序表的实现步骤1、定义顺序表结构体，包括数据数组和长度变量。
2、实现顺序表的初始化函数，将长度初始化为 0。
3、插入操作：首先判断表是否已满，如果未满，在指定位置插入元素，并将后续元素后移。
4、删除操作：首先判断指定位置是否合法，然后将该位置元素删除，并将后续元素前移。
5、查找操作：遍历表中的元素，找到目标元素返回其位置，否则返回－1。
（二）链表的实现步骤1、单向链表定义单向链表节点结构体，包含数据和指向下一个节点的指针。
实现链表的初始化函数，创建头节点。
插入操作：分为头插法和尾插法，根据插入位置的不同选择相应的方法。
删除操作：找到要删除的节点，将其前后节点连接起来，释放删除节点的内存。
查找操作：遍历链表，找到目标元素返回节点指针，否则返回NULL。
2、双向链表定义双向链表节点结构体，包含数据、指向前一个节点和指向下一个节点的指针。
初始化函数与单向链表类似，但需要同时处理前后指针。
插入和删除操作：在单向链表的基础上，同时更新前后节点的指针。
数据结构实验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<<"种摆放方法。
青岛理工大学数据结构第二次实验报告
青岛理工大学数据结构课程实验报告
算法描述及实验步骤
template <class T>
class SQList//顺序表
template <class T>
class SQListjcb//顺序表的交叉并template <class T>
class SQLnode//单链表
template <class T>
class SQLnodejcb//链表的交叉并
调试过程及实验结果
总结本次试验对于顺序表和链表的优缺点的认识更加深刻。
顺序表中进行查找操作时较方便，而链表则适合进行插入和删除运算。
顺序表存储密度大，存储空间利用率高；链表插入和删除运算时很方便，使用灵活。
求集合的交并差运算用顺序表和链表实现时，顺序表的程序比较好做一点，因为是使用另一个数组C来存储运算结果，所以并没有在数组中进行插入和删除运算，程序较简单；而做链表时遇到了困难，再插入新节点时程序总是不能运行。
附录#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 #define OVERLOW -2 #include<iostream>
#include<string>
#include<windows.h> using namespace std;。
数据结构试验二最终报告
第一个链表元素为（1，3，6，10，15，16，17，18，19，20）
第二个链表元素为（2，4，5，7，8，9，12，22）
第三组
第一个链表元素为（）
第二个链表元素为（1，2，3，4，5，6，7，8，9，10）
<4>编写算法以构造带头结点的双循环链表。
第一组数据：链表元素为（1，2，3，4，5，6，7，8，9，10）
第二组数据：链表元素为（10，30，40，55，60，70，88，99，100）
<5>编写算法以判断一个带头结点的双循环链表是否是对称的，若成立，返回TRUE，否则返回FALSE。
第一组数据：链表元素为（1，2，3，4，5，4，3，2，1）
第二组数据：链表元素为（1，2，3，4，5，5，4，3，2，1）
第二组数据：链表元素为（1，2，3，4，5，6，7，8，9，10，11，12，13，15，20，18）
<3>利用递增有序的单循环链表表示集合，分别求两个链表表示的集合的交、并集所构成的链表。
第一组
第一个链表元素为（1，3，6，10，15，16，17，18，19，20）
第二个链表元素为（1，2，3，4，5，6，7，8，9，10，18，20，30）
第二组数据：链表元素为（10，20，30，40，50，60，70，80，90，100）
<2>设计算法以判断一个带头结点的单循环链表是否满足这样的条件：其中每个结点的元素值与其序号的差的绝对值不大于３。若成立，返回TRUE，否则返回FALSE。
第一组数据：链表元素为（1，2，3，4，5，6，7，8，9，10，12，13，15，16，18）
第一组数据返回True第二组数据返回False
数据结构第二次实验报告
数据结构课程设计报告题目：魔王语言解释院系：信息学院班级：信管11-1姓名：丁升学号：201101050905指导教师：张晓庆实习报告题目：编制一个魔王语言翻译的程序班级：信息管理与信息系统11-1 姓名：丁升学号：201101050905 完成日期：2013.6.5一、需求分析1. 本演示程序中，魔王语言限制在小写字母‘a’-‘z’之间，且必须限制在括号内以及大写字母A和B。
且允许出现重复字符或非法字符，程序运用时自动过滤去，输出的运算结果中将不含重复字符和非法字符。
2. 魔王语言遵守如下规则：（θδ1δ2δ3…δn）→θδnθδn-1…θδ1θB→tAdA A→sae3. 演示程序以用户和计算机对话的形式进行，即在计算机终端中显示提示信息之后，有用户自行选择下一步命令，相应输入数据和运算结果在其后显示。
4. 程序的执行命令有：1）选择操作 2）任意键结束5. 数据测试B(ehnxgz)B解释成：tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系，则魔王说的话是：“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。
二、概要设计为实现上述功能，需要栈和队列两个抽象数据类型。
1. 栈抽象数据类型定义ADT stack{数据对象：D={ai|ai∈Elemset,i=1,2,3,…n,n>=0}基本操作：InitStack(&s)操作结果：构造一个空栈s。
Push(&s, e)初始条件：栈s已存在。
操作结果：插入元素e为新的栈顶元素。
Pop(&s, &e)初始条件：栈s已存在且非空。
操作结果：删除栈s的栈顶元素，并用e返回其值。
StackLenth(&s)初始条件：栈s已存在。
操作结果：返回s的元素个数，即栈的长度。
ClearStack(&s)初始条件：栈s已存在。
操作结果：将s清为空栈。
数据结构实验报告二
数据结构实验报告（实验名称）1.实验目标熟练掌握栈的顺序存储结构和链式存储结构。
熟练掌握栈的有关算法设计，并在顺序栈和链栈上实现。
根据具体给定的需求，合理设计并实现相关结构和算法。
2.实验内容和要求内容：通过顺序栈和链栈结构设计并实现一个顺序栈，编写算法实现下列问题的求解。
<1>利用顺序栈实现将10进制数转换为16进制数。
第一组数据：4第二组数据：11第三组数据：254第四组数据：1357<2>对一个合法的数学表达式来说，其中的各大小括号“{”，“}”，“[”，“]”，“(”和“)”应是相互匹配的。
设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。
要求：顺序栈的实验要求顺序栈结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；程序有适当的注释。
链栈实验要求本次实验中的链栈结构指带头结点的单链表；链栈结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；程序有适当的注释。
3.数据结构设计顺序栈，链栈。
4.算法设计（除书上给出的基本运算（这部分不必给出设计思想），其它实验内容要给出算法设计思想）进制转换：先在函数中定义一个栈然后初始化栈，通过循环对x求余数，将余数放入栈中，循环取出栈中的元素，并判断其值，用switch-case，10-A，11-B，12-C，13-D，14-E，15-F。
判断符号是否配对：通过函数将栈传入，将栈中的元素放到一个数组中，然后通过循环给数组中的符号对应相反数数字，如“（”-1，“）”-（-1）。
判断是否合法时，将整数数组遍历相加，若和为0 ，表达式合法，若和不为0则不合法。
5.运行和测试顺序栈：1，2，链栈：1，26.总结和心得通过本次实验，很多东西还为掌握，要是不是的查书，查书时总结了一下内容栈是限定尽在表尾进行插入或者删除操作的线性表。
北京邮电大学 计算机学院 数据结构第二次实验报告
实验报告（2）姓名：学号：班级：日期：一、实验目的：掌握特殊线性表栈和队列的有关运算，熟悉栈和队列的存储结构的基本特点。
二、实验原理：完成特殊单链表-----栈和队列的运算。
具体：1、利用栈完成1个字符串的逆置运算；2、在一个循环队列中入队2元素的运算。
三、实验内容及要求：1、编写一个算法程序实现在一个顺序栈中把一个字符串逆置的运算，要求使用入栈和出栈运算来完成。
2、编写一个算法程序实现在一个循环队列中入队2个元素，要求先建立一个循环队列，元素个数为4个，然后在循环队列的末尾加入2个元素。
要求：请同学把步骤、调试好的程序及存在的问题写在下面。
第一题:步骤:首先创建一个空栈 ,然后提示用户输入一个字符串,依次读取字符串的每个字符并入栈 ,再依次取栈顶元素并出栈 ,便可得到原字符串的逆置。
第一题实验程序代码：#include <stdio.h>#define Stack_Size 50//数组大小定义typedef char DataType;typedef struct{DataType elem[Stack_Size];int top;}SeqStack;//栈的结构定义SeqStack *InitStack();//栈的创建函数int StackEmpty(SeqStack *S);//判断栈是否为空int StackFull(SeqStack *S);//判断栈是否为满void Push(SeqStack *S,DataType x);//元素入栈DataType Pop(SeqStack *S);//元素出栈void playdata(SeqStack *S);//打印输出栈中的元素int main(){SeqStack *S;char x;S=InitStack();if(S==NULL)return 0;printf("请输入一个字符串，以回车键结束：\n");//打印提示语x=getchar();while(x!='\n'){Push(S,x);x=getchar();}if(!StackEmpty(S))//判断字符串是否为空{printf("该字符串的逆序是：\n");playdata(S);}elseprintf("该字符串为空！\n");system("pause");return 0;}SeqStack *InitStack()//栈的创建函数{SeqStack *S;S=(SeqStack*)malloc(sizeof(SeqStack));if(S==NULL)return NULL;else{S->top=-1;return S;}}int StackEmpty(SeqStack *S)//判断栈是否为空{return S->top==-1;}int StackFull(SeqStack *S)//判断栈是否为满{return S->top==Stack_Size-1;}void Push(SeqStack *S,DataType x)//元素入栈{S->elem[++S->top]=x;}DataType Pop(SeqStack *S)//元素出栈{return S->elem[S->top--];}void playdata(SeqStack *S)//打印输出栈中的元素{int i=0;for(i=S->top;i>=0;i--){printf("%c",S->elem[i]);}printf("\n");}第二题:步骤：首先创建一个循环队列，接着在循环队列中入队四个元素，接着提示用户输入2个元素，再入队，再将入队后的队列元素从队头到队尾打印出来，程序结束。
山东大学数据结构第二次实验实验报告
实验2 ADT栈与队列的编程与实现实验目的：加深对抽象数据类型ADT栈和队列的理解；实验原理：参照课本p.64-66，及Figure3.39-3.44；课本p.82-83，及Figure3.57-3.60.实验内容：编写程序实现ADT栈的定义，及常用操作（数组或指针实现）：1)生成栈；2)Push3)Pop编写程序实现ADT队列的定义，及常用操作：1)生成队列；2)Enqueues入列；3)Isempty判断是否队列为空。
实验要求：1)实现ADT栈的结构及操作；2)实现ADT队列的结构及操作，并给出应用。
1.栈（链表实现）实验源程序：#include "stdafx.h"#include "stdio.h"#include "stdlib.h"#include "malloc.h"#include "string.h"typedef struct node //定义一个栈的结构{int data;struct node *pNext; //pNext为指向栈中下一个空间的指针}Node,*pNode;typedef pNode Stack;Stack InitStack() ; //初始化栈void CreateStack(Stack Top); //生成栈bool Empty(Stack Top); //判断栈是否为空void Push(Stack Top,int n); //进行压栈操作void Pop(Stack Top); //进行出栈操作void TraverseStack(Stack Top); //遍历栈的函数void DeleteStack(Stack Top); //清空栈的函数int main() //主函数{int n;char str[6]; //定义数组，存储操作指令Stack Top=NULL; //初始化Top为NULLTop=InitStack(); //初始化栈CreateStack(Top); //生成栈TraverseStack(Top); //遍历栈printf("请输入下一步操作指令(push,pop or end):");while(1){scanf("%s",str); //获取操作指令if(strcmp(str,"push")==0){printf("请输入入栈的元素:");scanf("%d",&n);Push(Top,n); //进栈操作TraverseStack(Top);printf("请输入下一步操作指令(push,pop or end):");}if(strcmp(str,"pop")==0){Pop(Top); //出栈操作TraverseStack(Top);printf("请输入下一步操作指令(push,pop or end):");}if(strcmp(str,"end")==0)break; //跳出循环if(strcmp(str,"push")!=0&&strcmp(str,"pop")!=0&&strcmp(str,"end")!=0) {printf("输入指令错误，请重新输入指令:");}}DeleteStack(Top); //释放栈空间return 0;}Stack InitStack() //进行栈的初始化的函数{Stack Top = (Stack)malloc(sizeof(Node)); //分配内存空间给栈顶if(Top==NULL){printf("动态分配内存失败\n");exit(1);}printf("初始化栈成功\n");Top->pNext = NULL; //栈顶指针的指向置为NULL；return Top;}void CreateStack(Stack Top) //生成栈{int LEN,x;Stack Bottom = Top; //令Top和Bottom指向同一空间Bottom->pNext = NULL;printf("请输入想要入栈的元素个数:");scanf("%d",&LEN);for(int i = 0; i < LEN; i++){printf("请输入第%d个元素(从栈顶到栈底):",i+1);scanf("%d",&x);Stack pNew = (Stack)malloc(sizeof(Node));pNew->data = x; //将输入的数放在栈data单元中Bottom->pNext = pNew; //Bottom指向新分配空间的单元pNew->pNext = NULL; //令pNew指向NULLBottom = pNew; //让新分配空间的单元成为栈底}printf("生成栈成功\n");}bool IsEmpty(Stack Top) // 判断栈是否为空{return Top->pNext==NULL;}void Push(Stack Top,int n) //进行进栈操作的函数{Stack pNew = (Stack)malloc(sizeof(Node)); //定义一个新节点，并分配内存空间if(pNew==NULL){printf("未能动态分配内存，进栈失败\n");return ;}pNew->data = n;pNew->pNext = Top->pNext;Top->pNext = pNew;}void Pop(Stack Top) //进行出栈操作函数{Stack p=Top->pNext;if (IsEmpty(Top)==true) //判断栈是否为空，为空就不能进行出栈操作{printf("栈为空，Pop失败\n");return ;}else{printf("弹出的栈顶元素为:");printf("%d \n",p->data); //显示出栈元素Top->pNext=p->pNext;free(p);}}void TraverseStack(Stack Top) //遍历栈，获取栈中的数值{printf("现在栈中的元素从栈顶到栈底依次为:");Stack p = Top->pNext;if(p==NULL)printf("栈空");while(p!=NULL){printf("%d ",p->data);p = p->pNext;}printf("\n");}void DeleteStack(Stack Top) //释放栈空间{Stack p,q ;p=Top->pNext;while (p != NULL){q=p->pNext;free(p);p=q;}Top->pNext=NULL;}实验结果：1）生成栈①初始化栈。
《数据结构》实验报告二(样例参考)
《数据结构》实验报告二系别：班级：学号：姓名：日期：指导教师：一、上机实验的问题和要求：单链表的查找、插入与删除。
设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求：1.从键盘输入10个字符，产生不带表头的单链表，并输入结点值。
2.从键盘输入1个字符，在单链表中查找该结点的位置。
若找到，则显示“找到了”；否则，则显示“找不到”。
3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。
4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。
5.（★）将单链表中值重复的结点删除，使所得的结果表中各结点值均不相同，输出单链表所有结点值，观察输出结果。
6.（★）删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。
7.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。
二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）1.程序结构：定义一个主函数和五个子函数（分别用来实现单链表的创建、查找、插入、删除及单链表的打印）。
2.数据结构：定义一个结构体，作为单链表的结点。
typedef struct stu /*DataType可以是任何相应的数据类型如int, float或char*/ {char Name[Max]; /*定义了数据域，这里存放的是一个字符型数组*/struct stu *next; /*定义了指针域*/}student;3.输入输出设计：创建单链表函数：student *create();输入：通过scanf( )函数及for语句为数据域定义，并定义指针域的指针所指的下一个结点。
数据结构实验报告二
return 0;
}
void main()
{
char str[MaxLen];
cnode *h;
printf("输入一个字符串：");
scanf("%s",str);
h=create(str);
if (judge(h)==1)
printf( " str是中心对称字符串\n");
else
printf("str不是中心对称字符串\n");
queue qu;
printf( "a入队\n");
enqueue (qu, 'a');
printf( "b入队\n");
enqueue (qu, 'b');
printf( "c入队\n");
enqueue (qu, 'c');
printf( "出队一次：");
dequeue (qu, &x);
printf( "%c\n",x);
教师评语
printf( "g入队\n");
enqueue (qu, 'g');
printf( "出队一次：");
dequeue (qu, &x);
printf("%c\n",x);
printf("余下元素出列：");
while (len>0)
{
dequeue (qu, &x);
printf("%c\n",x);
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
//若栈不空，则删除 S 的栈顶元素，用 e 返回其值，并返回 OK；否 //则返回 ERROR
实验步骤： （算法描述、源程序、操作步骤和方法）
洛阳师范学院信息技术学院 软件实验报告
专业： 网络工程 课程：数据结构
学号：131124007 姓名：郑小玉班级：13 级 实验名称 实验类型 验证性
栈和队列及其应用——数制转换
实验时间
2014.11.8
实验环境 实验目的与要求：
1.深入了解栈和队列的特性。
WindowsXP DEV-C++ 5
实验总结： 利用栈实现数制转换，构建栈是关键。另外也要熟悉对栈内元素输入输出的操作，还有要构建一 个实现数制转换的函数，最后就是对函数的调用。这次实验，我出错的地方大多都是函数变量没有定 义，还有就是要用的函数没有构造完整。因此，完成一个程序不仅要构造好骨架，而且要注意细节和 函数之间的关系。
实验步骤： （算法描述、源程序、操作步骤和方法） 算法描述：利用栈的操作实现数制转换 基本操作：构建一个栈 实现栈的输入输出 创建实现数制的转换 利用主函数调用来实现操作 源程序：Status InitStack(SqStack &S); //构造一个空栈 S Status StackEmpty(SqStack S); //若栈 S 为空栈，则返回 TRUE，否则返回 FALSE Status GetTop(SqStack S,SElemType &e); //若栈不空，则用 e 返回 S 的栈顶元素，并返回 OK；否则返回 ERROR Status Pop (SqStack &S,SElemType &e);
测试过程： （实验中出现的问题、错误、解决方法） 错误： [Linker error] undefined reference to `StackEmpty(SqStack)' [Linker error] undefined reference to `StackEmpty(SqStack)' ld returned 1 exit status 解决方法： 少了 StackEmpty 程序的调用 Status StackEmpty(SqStack S) { //若栈 S 为空栈，则返回 TRUE，否则返回 FALSE if(S.top==S.base) return TURE; else return ERROR; }// StackEmpty 错误： In function `Status InitStack(SqStack&)': `OVERFLOW' undeclared (first use this function) (Each undeclared identifier is reported only once for each function it appears in.) 解决方法：在头文件后加 #define OVERFLOW 0 定义 OVERFLOW 的量
2.巩固对这两种结构方法的掌握。 3.接触较复杂问题的递归算法设计。
签名 2014 年 评语与成绩：
郑小玉 11 月
20
容： （数制转换操作） int conversion(int N,int d) { //N:表示十进制正整数,d 表示 2 到 16 之间的某种进制 //面实现将十进制整数 N 转换成某种 d 进制数,并输出显示。 SqStack S; int e; InitStack(S);//构造空栈 while(N) { Push(S, N % d); N = N / d; } while(!StackEmpty(S)) { Pop(S,e); if(e<10) cout<<e; else cout<<e+55; } cout<<endl; }