数据结构实验四参考
天津理工大学数据结构实验报告4
附录（可包括源程序清单或其它说明）#include <stdio.h>#include <string>#define MAX_NAME 10#define MAX_INFO 80typedef char InfoType;typedef char V ertexType[MAX_NAME]; // 字符串类型#define MAX_VERTEX_NUM 20typedef enum{unvisited,visited}VisitIf;typedef struct EBox{VisitIf mark; // 访问标记int ivex,jvex; // 该边依附的两个顶点的位置struct EBox *ilink,*jlink; // 分别指向依附这两个顶点的下一条边InfoType *info; // 该边信息指针}EBox;typedef struct{V ertexType data;EBox *firstedge; // 指向第一条依附该顶点的边}V exBox;typedef struct{V exBox adjmulist[MAX_VERTEX_NUM];int vexnum,edgenum; // 无向图的当前顶点数和边数}AMLGraph;typedef int QElemType;typedef struct QNode{// 单链表的链式存储结构QElemType data; //数据域struct QNode *next; //指针域}QNode,*QueuePtr;typedef struct{QueuePtr front,//队头指针，指针域指向队头元素rear; //队尾指针，指向队尾元素}LinkQueue;// 若G中存在顶点u,则返回该顶点在无向图中位置;否则返回-1int LocateV ex(AMLGraph G,V ertexType u){int i;for(i=0;i<G.vexnum;++i)if(strcmp(u,G.adjmulist[i].data)==0)return i;return -1;}int CreateGraph(AMLGraph *G){ // 采用邻接表存储结构,构造无向图G int i,j,k,l,IncInfo;char s[MAX_INFO];V ertexType va,vb;EBox *p;printf("请输入无向图G的顶点数,边数: ");scanf("%d,%d",&(*G).vexnum,&(*G).edgenum);printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);for(i=0;i<(*G).vexnum;++i){ // 构造顶点向量scanf("%s",(*G).adjmulist[i].data);(*G).adjmulist[i].firstedge=NULL;}printf("请顺序输入每条边的两个端点(以空格作为间隔):\n");for(k=0;k<(*G).edgenum;++k){// 构造表结点链表scanf("%s%s%*c",va,vb); // %*c吃掉回车符i=LocateV ex(*G,va); // 一端j=LocateV ex(*G,vb); // 另一端p=(EBox*)malloc(sizeof(EBox));p->mark=unvisited; // 设初值p->ivex=i;p->jvex=j;p->info=NULL;p->ilink=(*G).adjmulist[i].firstedge; // 插在表头(*G).adjmulist[i].firstedge=p;p->jlink=(*G).adjmulist[j].firstedge; // 插在表头(*G).adjmulist[j].firstedge=p;}return 1;}V ertexType* GetVex(AMLGraph G,int v){ // 返回v的值if(v>=G.vexnum||v<0)exit(0);return &G.adjmulist[v].data;}// 返回v的第一个邻接顶点的序号。
数据结构实验报告4
数据结构实验报告——实验4学号：：得分：______________一、实验目的1、复习线性表的逻辑结构、存储结构及基本操作；2、掌握顺序表和（带头结点）单链表；3、了解有序表。
二、实验容1、（必做题）假设有序表中数据元素类型是整型，请采用顺序表或（带头结点）单链表实现：（1）OrderInsert(&L, e, int (*compare)(a, b))//根据有序判定函数compare，在有序表L的适当位置插入元素e；（2）OrderInput(&L, int (*compare)(a, b))//根据有序判定函数compare，并利用有序插入函数OrderInsert，构造有序表L；（3） OrderMerge(&La, &Lb, &Lc, int (*compare)())//根据有序判定函数compare，将两个有序表La和Lb归并为一个有序表Lc。
2、（必做题）请实现：（1）升幂多项式的构造，升幂多项式是指多项式的各项按指数升序有序，约定系数不能等于0，指数不能小于0；（2）两个升幂多项式的相加。
三、算法描述（采用自然语言描述）1.创建带头节点的链表，输入两个有序表数据La Lb归并两个有序表得有序表Lc输出三个有序表输入需插入数据e将e插入有序表Lc输出插入e后的Lc2.创建链表按指数升序输入多项式得序数和指数输出多项式按指数升序输入第二个多项式得序数和指数两个多项式相加输出第二个多项式和两个多项式得和四、详细设计（画出程序流程图）1.2.五、程序代码（给出必要注释）1.#include<stdio.h>#include<malloc.h>typedef struct LNode{int date;struct LNode *next;} LNode,*Link;typedef struct LinkList{Link head;//头结点int lenth;//链表中数据元素的个数} LinkList;int compare (LinkList *L,int e)//有序判定函数 compare {int Lc=0;Link p;p=L->head;p=p->next;while(p!=NULL){if(e>p->date){p=p->next;Lc++;}elsereturn Lc;}return Lc;}void OrderInsert (LinkList *L,int e,int (*compare)())//根据有序判定函数compare，在有序表L 的适当位置插入元素e；{Link temp,p,q;int Lc,i;temp=(Link)malloc(sizeof(LNode));temp->date=e;p=q=L->head;p=p->next;Lc=(*compare)(L,e);if(Lc==L->lenth){while(q->next!=NULL){q=q->next;}q->next=temp;temp->next=NULL;}else{for(i=0; i<Lc; i++){p=p->next;q=q->next;}q->next=temp;temp->next=p;}++L->lenth;}void OrderMerge (LinkList *La,LinkList *Lb,int (*compare)())//根据有序判定函数 compare ,将两个有序表 La 和 Lb 归并为一个有序表{int i,Lc=0;Link temp,p,q;q=La->head->next;while(q!=NULL){p=Lb->head;temp=(Link)malloc(sizeof(LNode));temp->date=q->date;Lc=(*compare)(Lb,q->date);if(Lc==Lb->lenth){while(p->next!=NULL){p=p->next;}p->next=temp;temp->next=NULL;}else{for(i=0; i<Lc; i++){p=p->next;}temp->next=p->next;p->next=temp;}q=q->next;++Lb->lenth;}}LinkList *Initialize (LinkList *NewList){int i;Link temp;NewList=(LinkList *)malloc((2+1)*sizeof(LinkList));for(i=0; i<2+1; i++){temp=(Link)malloc(sizeof(LNode));temp->date=0;temp->next=NULL;(NewList+i)->head=temp;(NewList+i)->lenth=0;}return NewList;}void Insert (LinkList *NewList){int a,i;char c;printf("在第1个表中插入数据,输入“ N ”再对下个表插入数据 \n");for(i=0; i<2; i++){while(1){scanf("%d",&a);c=getchar();if(c=='N'){if(i<2-2)printf("在第 %d个表中插入数据,输入“ N ”再对下个表插入数据 \n",i+2); else if(i==2-2)printf("在第 %d个表中插入数据,输入“ N ”结束。
数据结构实验四实验报告
桂林电子科技大学2014-2015学年 第2学期数据结构 实验报告实验名称 实验四 树辅导教师意见：成绩 教师签名：院 系 计算机科学与工程学院 专业 软件工程学 号 1300330129 姓名 张涛 同 作 者 实验日期2015 年 06 月 26 日一、实验目的1.了解树二、实验具体内容1、实验题目1：（1）题目 树（2）分析实验代码：#include<iostream>#include<stdio.h>#include<conio.h>using namespace std;typedef struct btnode {int data;btnode *Lchild,*Rchild;}*Btnode;void Creat(Btnode & t) {int ch; cin>>ch;if(ch==0) t=NULL;else {btnode *p=new btnode;p->data=ch; t=p;Creat(t->Lchild);Creat(t->Rchild);} }void Preorder(Btnode & p) {if(p!=NULL) {cout<<p->data<<"，";Preorder(p->Lchild);Preorder(p->Rchild); } } void Midorder(Btnode & p) {if(p!=NULL) {Midorder(p->Lchild);cout<<p->data<<"，";Midorder(p->Rchild); } } void Folorder(Btnode & p) {if(p!=NULL) {Folorder(p->Lchild);Folorder(p->Rchild);cout<<p->data<<"，"; }} void main() {btnode *head=new btnode;cout<<"请输入数据：";Creat(head);cout<<"前序遍历：";Preorder(head);cout<<endl;cout<<"中序遍历：";Midorder(head);cout<<endl;cout<<"后序遍历：";Folorder(head);getch(); }三、实验小结。
数据结构实验4-2
实验2稀疏矩阵的表示和转置实验人：学号:时间：2019.4.8一、实验目的1.掌握稀疏矩阵的三元组顺序表存储结构2.掌握稀疏矩阵的转置算法。
二、实验内容采用三元组表存储表示，求稀疏矩阵M的转置矩阵T。
（算法5.1）三、实验步骤：1.构建稀疏矩阵M。
2.求稀疏矩阵M的转置矩阵T。
3.输出稀疏矩阵M和稀疏矩阵T。
四、算法说明1.首先应输入矩阵的行数、列数和非零个数。
2.其次输入你所构建的稀疏矩阵，采用三元组顺序表存储表示，并判别给出的两个矩阵的行、列数进行稀疏矩阵的转置时要做到，将每个三元组的i，j相互调换；并且重排三元组之间的次序便可实现矩阵的转置。
3.主函数设置循环和选择语句进行运算循环和选择，进行稀疏矩阵的转置。
五、测试结果六、分析与探讨这次实验是稀疏矩阵的表示和转置编写的程序题，但是有关稀疏矩阵的写法在我平时上课时我就感觉有点难消化，以及对于矩阵的相关知识和三元组表的相关知识方面已经有些遗忘了。
所以在编写实验内容之前我把数据结构书上有关稀疏矩阵的内容反反复复又看了两遍，了解了三元组顺序表、行逻辑链接的顺序表以及十字表的方法。
在这次程序编写中我用到了三元组顺序表的方法。
首先，根据实验内容采用三元组表存储表示，求稀疏矩阵M的转置矩阵T所围绕的程序算法5.1进行编程以及调试；其次，根据课程设计的要求进行实验目的以及实验意义的分析；最后，根据实验步骤对主函数main 进行编写，将项目设计的算法思想，基本算法，主函数调用一一呈现出来。
主函数中主要包含构建稀疏矩阵M，输出构建稀疏矩阵M以及转置矩阵T三个部分。
在整个课程设计中总是在编写程序中发生一些很小的错误，比如对元素缺少定义、缺个分号以及大小写方面。
在编写的时候总会很粗心，有时会很没耐性，但都被我一一克服了，同时还有认真仔细，尽量保证不出现错误，看到自己的代码错误少了，也会更有信心和动力。
最后，编程时要注意要有条理，这样有利于修改错误，减少时间的花费。
数据结构-实验4
《数据结构》实验报告年级_2012级__ 学号_ 姓名 __ 成绩______专业_计算机科学与技术实验地点___指导教师__实验项目实验四串实验性质设计性实验日期：一、实验目的：1、掌握串的定义及其基本操作的实现。
2、掌握链表及其基本操作的实现。
3、通过上机实践进一步加深对串的顺序存储方式及链式存储方式的理解。
4、通过上机实践加强利用数据结构解决实际应用应用问题的能力。
二、实验内容与要求：1、实验题目一：顺序串的定义及其操作算法的实现要求：编程实现串的类型定义及串的初始化操作、插入操作、删除操作、取元素操作、输出操作等，并对其进行验证。
2、实验题目二：文本加密和解密要求：掌握每一种串操作的一般函数的实现及其应用。
三、实验问题描述一个文本串可用事先给定的字母映射表进行加密。
例如，设字母映射表为：abcdefghijklmnopqrstuvwxyzngzqtcobmuhelkpdawxfyivrsj则字符串“encrypt”被加密为“tkzwsdf”。
设计一个程序将输入的文本串进行加密后输出，然后进行解密输出。
四、实验步骤1．实验问题分析这里用到了c语言里的while 语句、for语句、if语句以及指针2．功能（函数）设计void Encrypt(char *pszSrc, char *pszEncrypt){char *p1;char *p2;int i=0;int j=0;p1=(char *)CharArray1;p2=(char *)CharArray2;cout<<"请输入要加密的字符串\n";fflush(stdin);cin.getline(pszSrc, 100);}五、实验结果（程序）及分析#include<iostream>using namespace std;const char CharArray1[26]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};const char CharArray2[26]={'n','g','z','q','t','c','o','b','m','u','h','e','l','k','p','d','a','w','x','f','y','i','v','r','s','j'};void Encrypt(char*pszSrc,char*pszEncrypt){char*p1;char*p2;int i=0;int j=0;p1=(char*)CharArray1;p2=(char*)CharArray2;cout<<"请输入要加密的字符串\n";fflush(stdin);cin.getline(pszSrc,100);i=0;j=0;while(*(pszSrc+i)!='\0'){for(j=0;j<26;j++){if(*(pszSrc+i)==*(p1+j)){*(pszEncrypt+i)=*(p2+j);break;}else{;}}i++;}*(pszEncrypt+i)='\0';}void Decrypt(char*pszSrc,char*pszDecrypt) {char*p1;char*p2;int i=0;int j=0;p1=(char*)CharArray1;p2=(char*)CharArray2;cout<<"请输入一行已加密的字符串:\n"; fflush(stdin);cin.getline(pszSrc,100);i=0;j=0;while(*(pszSrc+i)!='\0'){for(j=0;j<26;j++){if(*(pszSrc+i)==*(p2+j)){*(pszDecrypt+i)=*(p1+j);break;}else{;}}i++;}*(pszDecrypt+i)='\0';}int main(){char*pszSrc;char*pszDest;int select;int i=0;int j=0;if((pszSrc=new char[100])==NULL){cout<<"申请内存空间失败,程序退出!\n";exit(1);}if((pszDest=new char[100])==NULL){cout<<"申请内存空间失败,程序退出!\n";exit(1);}while(1){cout<<"请选择加密或解密(1.加密2.解密0.退出):";cin>>select;if(1==select){Encrypt(pszSrc,pszDest);cout<<"加密后的字符串\n";i=0;while(*(pszDest+i)!='\0'){cout<<*(pszDest+i);i++;}cout<<endl;}else if(2==select){Decrypt(pszSrc,pszDest);cout<<"解密后的字符串\n";i=0;while(*(pszDest+i)!='\0'){cout<<*(pszDest+i);i++;}cout<<endl;}else if(0==select){break;}else{cout<<"你没有输入正确的选择,请重新选择:";}}delete[]pszSrc;delete[]pszDest;return0;}六、结论与分析在本次实验中掌握了串的各种操作，以及其实际作用，掌握串的定义及其基本操作的实现和掌握链表及其基本操作的实现。
《数据结构》实验报告查找
实验四——查找一、实验目的1.掌握顺序表的查找方法，尤其是折半查找方法；2.掌握二叉排序树的查找算法。
二、实验内容1.建立一个顺序表，用顺序查找的方法对其实施查找；2.建立一个有序表，用折半查找的方法对其实施查找；3.建立一个二叉排序树，根据给定值对其实施查找；4.对同一组数据，试用三种方法查找某一相同数据，并尝试进行性能分析。
三、实验预习内容实验一包括的函数有：typedef struct ，创建函数void create(seqlist & L)，输出函数void print(seqlist L)，顺序查找int find(seqlist L,int number)，折半查找int halffind(seqlist L,int number)主函数main().实验二包括的函数有：结构体typedef struct，插入函数void insert(bnode * & T,bnode * S)，void insert1(bnode * & T)，创建函数void create(bnode * & T)，查找函数bnode * search(bnode * T,int number)，主函数main().四、上机实验实验一：1.实验源程序。
#include<>#define N 80typedef struct{int number; umber;for(i=1;[i].number!=0;){cin>>[i].name>>[i].sex>>[i].age;++;cout<<endl;cin>>[++i].number;}}umber<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;}umber==number)return i;}umber)return mid;elseif(number<[mid].number)high=mid-1;elselow=mid+1;}return 0;}void main(){int i,number;seqlist L;create(L);print(L);cout<<"折半查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=halffind(L,number))!=0)cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;elsecout<<"失败!"<<endl;cout<<"顺序查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=find(L,number))!=0)cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;elsecout<<"失败!"<<endl;}实验二：#include<>typedef struct{int number; 立二叉排序树"<<"\n\t2.插入学生信息"<<"\n\t3.查找学生信息"<<endl;cout<<"选择:";cin>>choice;switch(choice){case 1:{create(T);cout<<"成功建立!"<<endl;};break;case 2:{insert1(T);cout<<"插入成功!"<<endl;};break;case 3:{cout<<"输入待查学生的学号:";cin>>number;p=search(T,number);if(p)cout<<p-><<"\t"<<p-><<"\t"<<p-><<"\t"<<p-><<endl;elsecout<<"查找失败!"<<endl;};break;}cout<<"Continue(Y/N):";cin>>ctinue;if(ctinue=='y'||ctinue=='y')flag=1;elseflag=0;}}2.实验结果（截图）。
数据结构实验报告
数据结构实验报告数据结构实验报告1.实验目的1.1 理解数据结构的基本概念和原理1.2 掌握数据结构的常用算法和操作方法1.3 培养编写高效数据结构代码的能力2.实验背景2.1 数据结构的定义和分类2.2 数据结构的应用领域和重要性3.实验内容3.1 实验一：线性表的操作3.1.1 线性表的定义和基本操作3.1.2 实现顺序存储结构和链式存储结构的线性表 3.1.3 比较顺序存储结构和链式存储结构的优缺点3.2 实验二：栈和队列的实现3.2.1 栈的定义和基本操作3.2.2 队列的定义和基本操作3.2.3 比较栈和队列的应用场景和特点3.3 实验三：树的操作3.3.1 树的定义和基本概念3.3.2 实现二叉树的遍历和插入操作3.3.3 比较不同类型的树的存储结构和算法效率3.4 实验四：图的遍历和最短路径算法3.4.1 图的定义和基本概念3.4.2 实现深度优先搜索和广度优先搜索算法3.4.3 实现最短路径算法（例如Dijkstra算法）4.实验步骤4.1 实验一的步骤及代码实现4.2 实验二的步骤及代码实现4.3 实验三的步骤及代码实现4.4 实验四的步骤及代码实现5.实验结果与分析5.1 实验一的结果和分析5.2 实验二的结果和分析5.3 实验三的结果和分析5.4 实验四的结果和分析6.实验总结6.1 实验心得体会6.2 实验中存在的问题及解决方案6.3 对数据结构的理解和应用展望7.附件实验所使用的源代码、运行截图等相关附件。
8.法律名词及注释8.1 数据结构：指计算机中数据的存储方式和组织形式。
8.2 线性表：一种数据结构，其中的元素按照顺序排列。
8.3 栈：一种特殊的线性表，只能在一端进行插入和删除操作。
8.4 队列：一种特殊的线性表，按照先进先出的顺序进行插入和删除操作。
8.5 树：一种非线性的数据结构，由节点和边组成。
8.6 图：一种非线性的数据结构，由顶点和边组成。
数据结构 实验报告
数据结构实验报告数据结构实验报告一、引言数据结构是计算机科学中非常重要的一门课程，它涉及到数据的存储、组织和管理等方面。
通过实验学习，我们可以更好地理解和掌握不同的数据结构，提升我们在编程中解决实际问题的能力。
二、实验目的本次实验的主要目的是通过实际操作，加深对数据结构的理解，学习并掌握不同数据结构的特点和应用场景，提高编程能力。
三、实验内容1. 实验环境的搭建在开始实验之前，我们需要搭建相应的实验环境。
首先，我们选择合适的集成开发环境（IDE），如Eclipse或IntelliJ IDEA，并安装好Java Development Kit（JDK）。
然后，根据实验要求，下载并安装相应的数据结构库或框架。
2. 实验一：线性表线性表是最基本且最常用的数据结构之一，它可以用于存储一系列具有相同数据类型的元素。
实验中，我们需要实现一个线性表的基本操作，包括插入、删除、查找、修改等。
3. 实验二：栈和队列栈和队列是两种常用的数据结构，它们都是线性表的衍生结构，但在操作上有一些特殊的限制。
实验中，我们需要实现栈和队列的基本操作，并比较它们在不同场景下的优劣。
4. 实验三：树和二叉树树是一种非线性的数据结构，它以分层的方式存储数据。
二叉树是树的一种特殊情况，其中每个节点最多只有两个子节点。
实验中，我们需要实现树和二叉树的构建和遍历算法，并掌握它们在实际问题中的应用。
5. 实验四：图图是一种非线性的数据结构，由节点和边组成。
实验中，我们需要实现图的构建和遍历算法，并应用它们解决实际的图相关问题。
四、实验结果与分析通过实验，我们得到了以下结果和分析：1. 在线性表实验中，我们成功实现了插入、删除、查找和修改等基本操作，并验证了其正确性和效率。
2. 在栈和队列实验中，我们对比了它们在不同场景下的应用，发现栈适用于后进先出（LIFO）的情况，而队列适用于先进先出（FIFO）的情况。
3. 在树和二叉树实验中，我们掌握了树和二叉树的构建和遍历算法，并应用它们解决了一些实际问题，如树形结构的存储和搜索。
《数据结构》 实验报告4
xxx实验报告课程名称数据结构实验名称实验四排序操作系部班级姓名学号实验时间2012 年12月10日时分～时分地点机位评语指导教师：成绩一、实验目的1. 掌握常用的排序方法，并掌握用高级语言实现排序算法的方法；2. 深刻理解排序的定义和各种排序方法的特点，并能加以灵活应用；3. 了解各种方法的排序过程及其时间复杂度的分析方法。
二、实验内容统计成绩：给出n个学生的考试成绩表，每条信息由姓名和分数组成，试设计一个算法：（1）按分数高低次序，打印出每个学生在考试中获得的名次，分数相同的为同一名次；（2）按名次列出每个学生的姓名与分数。
三、实验步骤1. 定义结构体。
2. 定义结构体数组。
3. 定出主程序，对数据进行排序。
四、程序主要语句及作用1. 程序原代码如下：#include <string.h>#include "stdio.h"#include <malloc.h>#include <conio.h>typedef struct BSTNODE{int data;struct BSTNODE *lchild;struct BSTNODE *rchild;}BSTNODE;BSTNODE* initBST(int n, BSTNODE *p){if(p==NULL){p=(BSTNODE*)malloc(sizeof(BSTNODE));p->lchild=NULL;p->rchild=NULL;p->data=n;}else if(n>p->data)p->rchild=initBST(n,p->rchild);elsep->lchild=initBST(n,p->lchild);return p;}void inorder(BSTNODE *BT){if(BT!=NULL){inorder(BT->lchild);printf("%d ",BT->data);inorder(BT->rchild);}}BSTNODE *search_btree(BSTNODE *root,int key) { if (!root){printf("Emptu btree\n"); return root; }while(root->data!=key){ if(key<root->data)root=root->lchild;elseroot=root->rchild;if(root==0){ printf("Search Failure\n");break ;}} /* while(root->info!=key) */if (root !=0)printf("Successful search\n key=%d\n",root->data);return root ;} /* *search_btree(root,key) */int main(){BSTNODE *p=NULL;int i,n,sd;int a[100];printf("enter the number of nodes:");scanf("%d",&n);printf("enter the number of the tree:");for(i=0;i<n;i++){scanf("%d",&a[i]);p=initBST(a[i],p);}inorder(p);printf("\n please input search data:");scanf("%d",&sd);search_btree(p,sd);getch();return 1;}2. 运行结果截图：五、总结体会本次试验让我学习到了很多也认识到了自己的不足：1.大部分的时间都用在了编程上，主要是因为C语言掌握的问题，C语言基础不好特别是对于C语言中链表的一些定义和基本操作不够熟练，导致在编程过程中还要不断的拿着c语言的教材查找，所以今后还要对C语言多练习，多动手，多思考。
数据结构课程实验报告
数据结构课程实验报告数据结构课程实验报告引言：数据结构是计算机科学中非常重要的一门课程，它研究了数据的组织、存储和管理方法。
在数据结构课程中，我们学习了各种数据结构的原理和应用，并通过实验来加深对这些概念的理解。
本文将对我在数据结构课程中的实验进行总结和分析。
实验一：线性表的实现与应用在这个实验中，我们学习了线性表这种基本的数据结构，并实现了线性表的顺序存储和链式存储两种方式。
通过实验，我深刻理解了线性表的插入、删除和查找等操作的实现原理，并掌握了如何根据具体应用场景选择合适的存储方式。
实验二：栈和队列的实现与应用栈和队列是两种常见的数据结构，它们分别具有后进先出和先进先出的特点。
在这个实验中，我们通过实现栈和队列的操作，加深了对它们的理解。
同时，我们还学习了如何利用栈和队列解决实际问题，比如迷宫求解和中缀表达式转后缀表达式等。
实验三：树的实现与应用树是一种重要的非线性数据结构，它具有层次结构和递归定义的特点。
在这个实验中，我们学习了二叉树和二叉搜索树的实现和应用。
通过实验，我掌握了二叉树的遍历方法，了解了二叉搜索树的特性，并学会了如何利用二叉搜索树实现排序算法。
实验四：图的实现与应用图是一种复杂的非线性数据结构，它由节点和边组成，用于表示事物之间的关系。
在这个实验中，我们学习了图的邻接矩阵和邻接表两种存储方式，并实现了图的深度优先搜索和广度优先搜索算法。
通过实验，我深入理解了图的遍历方法和最短路径算法，并学会了如何利用图解决实际问题，比如社交网络分析和地图导航等。
实验五：排序算法的实现与比较排序算法是数据结构中非常重要的一部分，它用于将一组无序的数据按照某种规则进行排列。
在这个实验中，我们实现了常见的排序算法，比如冒泡排序、插入排序、选择排序和快速排序等，并通过实验比较了它们的性能差异。
通过实验，我深入理解了排序算法的原理和实现细节，并了解了如何根据具体情况选择合适的排序算法。
结论：通过这些实验，我对数据结构的原理和应用有了更深入的理解。
《数据结构》实验指导及实验报告栈和队列
《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的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题的程序中，编写⼀个⼗进制转换为⼆进制的数制转换算法函数（要求利⽤栈来实现），并验证其正确性。
数据结构实验报告(实验)
数据结构实验报告(实验)数据结构实验报告(实验)1. 实验目的1.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统：Windows 102.2 编程语言：C++2.3 开发工具：Visual Studio3. 实验内容3.1 实验一：线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二：栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三：树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法（前序、中序、后序遍历）3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一：实验源代码附件二：实验数据7. 法律名词及注释7.1 版权：著作权法规定的对原创作品享有的权利7.2 专利：国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标：作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议：指允许他人在一定条件下使用自己的知识产权的协议。
武汉纺织大学《数据结构》实验报告4
武汉纺织大学《数据结构》实验报告班级：级管工类专业班姓名：序号： 1实验时间： 2014 年 5 月 30 日指导教师：实验四：查找基本操作与应用一、实验目的：1、掌握顺序查找、折半查找、哈希查找的基本方法和操作过程2、掌握查找效率的分析方法二、实验内容：1、编写程序，实现顺序查找操作，可参考书本P260示例程序。
实验步骤：①、在Java语言编辑环境中新建程序，建立一个顺序表（表长10），依次输入10个数据元素（对元素存放的先后顺序没有要求），并按照存储顺序输出所有元素；②、输入带查找关键字，在顺序表中进行顺序查找；③、输出查找结果。
2、编写程序，实现有序表折半查找操作，可参考书本P263示例程序。
实验步骤：①、在Java语言编辑环境中新建程序，建立一个顺序表（表长10），依次输入10个数据元素（要求所有元素按照递增顺序排列），并按照存储顺序输出所有元素；②、输入带查找关键字，在有序表中进行折半查找；③、输出查找结果。
3、编写程序，实现哈希表查找操作。
实验步骤：①、在Java语言编辑环境中新建程序，建立一个顺序表（表长12），依次输入10个数据元素，并按照存储顺序输出所有元素；②、输入带查找关键字，在哈希表中进行查找；③、输出查找结果。
已知：哈希函数为H(key)=key MOD 11，采用开放地址法、线性探测再散列解决冲突，输入元素为{ 55,19,31,23,68,20,27,9,10,79}。
三、操作步骤：Test1代码：T1.Javapackage First;import java.util.Scanner;public class T1 {public static void main(String[] args) {int i;int n;Scanner sc=new Scanner(System.in);SeqList<Integer> sl=new SeqList<Integer>(10);sl.insert(0, 3);sl.insert(6, 1);sl.insert(6, 0);sl.insert(8, 6);sl.insert(7, 2);sl.insert(2,9);sl.insert(4, 1);sl.insert(5, 4);sl.insert(6,8);sl.insert(1, 7);System.out.print("顺序表中各元素:");System.out.println(sl.toString());System.out.println("<查找元素>");System.out.print("输入元素:");i=sc.nextInt();n=sl.indexOf(i);if(n!=-1)System.out.println("元素" +i+"位于第"+n+"位");}}LList.javapackage First;public interface LList<T> {boolean isEmpty();int length();T get(int i);void set(int i, T x);void insert(int i, T x);T remove(int i);void removeAll();}SeqList .javapackage First;public class SeqList<T> implements LList<T> { private Object[] element;private int len;public SeqList(int size) {this.element = new Object[size];this.len = 0;}public SeqList() {this(64);}public boolean isEmpty() {return this.len == 0;}public int length() {return this.len;}public T get(int i) {if (i >= 0 && i < this.len)return (T) this.element[i];return null;}public void set(int i, T x) {if (x == null)return;if (i >= 0 && i < this.len)this.element[i] = x;elsethrow new IndexOutOfBoundsException(i + "");}public String toString() {String str = "(";if (this.len > 0)str += this.element[0].toString();for (int i = 1; i < this.len; i++)str += "," + this.element[i].toString();return str + ")";}public void insert(int i, T x){if(x==null)return;if(this.len==element.length){Object[]temp = this.element;this.element = new Object[temp.length*2];for(int j=0;j<temp.length;j++)this.element[j]=temp[j];}if(i<0)i=0;if(i>this.len)i=this.len;for(int j=this.len-1;j>=i;j--)this.element[j+1]=this.element[j];this.element[i]=x;this.len++;}public void append(T x){ insert(this.len,x); } public T remove(int i){if(this.len==0||i<0||i>=this.len)return null;T old = (T)this.element[i];for(int j=i;j<this.len-1;j++)this.element[j]=this.element[j+1];this.element[this.len-1]=null;this.len--;return old;}public void removeAll(){ this.len=0; } public int indexOf(T key){if(key!=null)for(int i=0;i<this.len;i++)if(this.element[i].equals(key))return i;return -1;}public T search(T key){int find=this.indexOf(key);return find==-1?null:(T)this.element[find]; }public boolean contain(T key){return this.indexOf(key)>=0;}}运行结果：Test2代码：T2.javapackage Second;public class T2 {public static void main(String[] args) {int a[]={5,11,23,15,17,38,90,121,132,164}; int search=38;int lower=0;int temp=a.length-1 ;int index=-1;while(lower<=temp){index = (lower+temp)/2;int currentValue=a[index];if(currentValue==search){break;}else if(currentValue<search){lower=index+1;}else{temp = index-1;}}for(int i = 0;i < 10; i++){System.out.print(a[i]);System.out.println(" ");}if(lower<=temp){System.out.println("查找元数"+search);System.out.println("位于数组中第"+(index+1)+"位");}else{System.out.println("里面没有这个元素"); }}}运行结果：Test3代码：T3.javapackage Three;import java.util.Scanner;public class T3 {static HashTable T=null;public static void createHashtable() throws Exception { T=new HashTable(20);Scanner sc=new Scanner(System.in);System.out.print("请输入待查找的关键字的个数:");int n=sc.nextInt();System.out.print("请输入查找表中的关键字序列:");for (int i = 0; i < n; i++) {T.hashInsert(sc.nextInt());}}public static void main(String[]args)throws Exception{System.out.println("<创建哈希表>");createHashtable();System.out.println("创建的哈希表为:");T.Hashdisplay();System.out.print("输入待查找的关键字:");Scanner sc=new Scanner(System.in);int key=sc.nextInt();RecordNode p=T.hashSearch(key);if ((p.getKey()).compareTo(key)==0)System.out.println(" 查找成功!");elseSystem.out.println(" 查找失败!");}}KeyType.javapackage Three;public class KeyType implements Comparable<KeyType> {private int key;public KeyType() {}public KeyType(int key) {this.key = key;}public int getKey() {return key;}public void setKey(int key) {this.key = key;}public String toString() {return key + "";}public int compareTo(KeyType another) {int thisVal = this.key;int anotherVal = another.key;return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));}}class HashTable {private RecordNode[] table;public HashTable(int size) {this.table = new RecordNode[size];for (int i = 0; i < table.length; i++) {table[i] = new RecordNode(0);}}public int hash(int key) {return key % 11;}public RecordNode hashSearch(int key) {int i = hash(key);int j = 0;while ((table[i].getKey().compareTo(0) != 0)&& (table[i].getKey().compareTo(key) != 0)&& (j < table.length)) {j++;i = (i + j) % 11;}if (j >= table.length) {System.out.println("哈希表已满");return null;} elsereturn table[i];}public void hashInsert(int key) {RecordNode p = hashSearch(key);if (p.getKey().compareTo(0) == 0)p.setKey(key);elseSystem.out.println(" 此关键字记录已存在或哈希表已满");}void Hashdisplay() {for (int i = 0; i < table.length; i++)System.out.print(table[i].getKey().toString() + " ");System.out.println();}}RecordNode.javapackage Three;public class RecordNode {private Comparable key;private Object element;public Object getElement() {return element;}public void setElement(Object element) {this.element = element;}public Comparable getKey() {return key;}public void setKey(Comparable key) {this.key = key;}public RecordNode() {this.key = null;}public RecordNode(Comparable key) {this.key = key;}}运行结果：四、实验收获和建议这次实验我掌握了顺序查找、折半查找、哈希查找的基本方法和操作过程，掌握查找效率的分析方法，对查找方法有了更进一步的认识。
北理工数据结构实验报告4
《数据结构与算法统计》实验报告——实验四学院：班级：学号：姓名：一、实验目的1、熟悉VC 环境，学会使用C 语言利用顺序表解决实际问题。
2、通过上机、编程调试，加强对线性表的理解和运用的能力。
3、锻炼动手编程，独立思考的能力。
二、实验内容从键盘输入10个数，编程实现分别用插入排序、交换排序、选择排序算法进行排序，输出排序后的序列。
三、程序设计1、概要设计为了实现排序的功能，需要将输入的数字放入线性表中，进行进一步的排序操作。
(1)抽象数据类型：ADT SqList{数据对象：D={|,1,2,,,0}i i a a ElemSet i n n ∈=≥数据关系：R1=11{,|,,1,2,,}i i i i a a a a D i n --<>∈= 基本操作：Input(Sqlist & L)操作结果：构造一个线性表L 。
output(SqList L)初始条件：线性表L 已存在。
操作结果：按顺序在屏幕上输出L 的数据元素。
BiInsertionsort (Sqlist L)初始条件：线性表L 已存在。
操作结果：对L 的数据元素进行折半插入排序。
QuickSort (Sqlist L)初始条件：线性表L 已存在。
操作结果：对L 的数据元素进行交换排序。
SelectSort(SqList &L)初始条件：线性表L 已存在。
操作结果：对L 的数据元素进行选择排序。
}ADT SqList⑵ 宏定义#define KeyType int#define MAXSIZE 10#define ok 1#define error 0⑶主程序流程由主程序首先调用Input(L)函数创建顺序表，先调用BiInsertionsort (L)函数进行折半插入排序，调用output(L)函数显示排序结果。
再调用QuickSort (L)函数进行交换排序，调用output (L)函数显示排序结果。
数据结构实验答案
实验一：以单链表表示集合，设计算法建立先后输入的两个集合的差。
说明：已知两个集合A和B，集合A-B中包含所有属于集合A而不属于集合B 的元素。
步骤：1.首先建立A和B的单链表2.然后对集合B中的每个元素x，在A中查找，若存在和x相同的元素，则从该链表中删除。
3.打印A-B，进行验证。
实验二：建立一个二叉树，并进行先序和中序遍历。
（递归和非递归算法）步骤1.补充元素0建立一个满二叉树，存储到一维数组2.利用递归算法建立二叉树，注意零的元素处置3．进行递归、非递归的中序和先序遍历。
打印结果。
实验三：先从键盘输入26个字母生成无序数组，对数组排序后，再从键盘输入一个字符进行折半查找。
实验四：为一个图（maxnode＝20）建立一个邻接表、编写深度遍历和广度遍历算法并给出遍历结果。
实验一答案：#include<stdio.h>typedef struct linknode{int data;struct linknode *next;} node;node *creatlist(){node *head,*r,*s;int x;head=(node*)malloc(sizeof(node));r=head;printf("input int and end with \n");scanf("%d",&x);while(x!=0){s=(node*)malloc(sizeof(node));s->data=x;r->next=s;s->next=NULL;r=s;scanf("%d",&x);}r->next=NULL;s=head;head=head->next;free(s);return(head);}void subs(){node *p,*p1,*p2,*q,*heada,*headb;heada=creatlist();headb=creatlist();p=heada;p1=p;while(p!=NULL){q=headb;while(q->data!=p->data && q!=NULL) q=q->next; if(q!=NULL){if(p==heada){heada=heada->next;p1=heada;}else if(p->next==NULL) p1->next=NULL;else p1->next=p->next;p2=p->next;p->next=NULL;free(p);p=p2;}else{p1=p;p=p->next;}}p=heada;if(p==NULL)printf("kong\n");elseprintf(" A - B \n");while(p!=NULL){printf("%d\n",p->data);p=p->next;}}main(){subs();}实验二答案：//程序目的建立二叉树，同时对他进行先序排列。
《数据结构》实验书
目录实验一线性表基本操作的编程实现 (201)实验二堆栈或队列基本操作的编程实现 (49)实验四二维数组基本操作的编程实现 (18)实验五二叉树基操作的编程实现 (20)实验六图基本操作的编程实现 (45)（特别提示：程序设计包含两个方面的错误。
其一是错误，其二是能错误。
为了提高学生的编程和能力，本指导书给出的程序代码并的两种错误。
并且也不保证程序的完整性，有一些语句已经故意删除，就是要求学生自己编制完成，这样才能达到我们的要求。
希望大家以自己所学高级语言的基本功和点为基础，不要过于依赖给出的参考代码，这样才能有所进步。
如果学生能够根据要求完全自己编制，那就不好了。
）实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求：线性表基本操作的编程实现（2学时，验证型），掌握线性表的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、逆序、排序等操作，存储结构可以在顺序结构或链表结分主要功能，也可以用菜单进行管理完成大部分功能。
还鼓励学生利用基本操作进行一些更实际的应用型程序设计。
【实验性质】【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。
建议实现键盘输入数据以实现程序的通据的函数。
【注意事项】【思考问题】1.线性表的顺序存储和链表存储的差异？优缺点分析？2.那些操作引发了数据的移动？3.算法的时间效率是如何体现的？4.链表的指针是如何后移的？如何加强程序的健壮性？【参考代码】（一）利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1)#define ListSize //根据需要自己设定一个班级能够容纳的最大学生数(2)typedef struct Stu{int num; //学生的学号char name[10]; //学生的姓名float wuli; //物理成绩float shuxue; //数学成绩float yingyu; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{stu[ListSize]; //存放学生的数组定义，静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=0;i<m;i++) //输入m个学生的所有信息{printf("please input the %dth student's information:\n",i+1);printf("num=");scanf("%d", ); //输入第i个学生的学号printf("name=");scanf("%s", ); //输入第i个学生的姓名printf("wuli=");scanf("%f", ); //输入第i个学生的物理成绩printf("shuxue=");scanf("%f", ); //输入第i个学生的数学成绩printf("yingyu=");scanf("%f", ); //输入第i个学生的英语成绩Li->length++; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。
国家开放大学《数据结构》课程实验报告(实验4——二叉树)参考答案
（实验4二叉树）
学生姓名
学 号
班 级
指导老师
实验名称
实验成绩
实验报告
实ቤተ መጻሕፍቲ ባይዱ
验
概
述
实验目的：
（1）根据数组tree，建立与该二叉树对应的链式存储结构。
（2）对该二叉树采用中序遍历法显示遍历结果。
实验要求：
（1）在主函数中，通过键盘输入建立设定的完全二叉树的顺序存储结构。
（2）设计子函数，其功能为将顺序结构的二叉树转化为链式结构。
（2）中序遍历采用递归算法，即中序遍历左子树、访问根结点、中序遍历右子树。
实
验
内
容
程序代码：
/*实验3.1二叉树的顺序存储结构和链式存储结构*/
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 20
/*二叉树链式存储结构结点定义*/
typedef struct BTreeNode
指
导
教
师
评
语
指导教师 日期
（3）设计子函数，其功能为对给定二叉树进行中序遍历，显示遍历结果。
（4）通过实例判断算法和相应程序的正确性。
实验基本原理：
（1）顺序存储的二叉树转化为链式存储结构，采用递归算法，递归函数的形式为Creab(tree,n,i,b)，其中形参：tree为顺序存储二叉树的数组，n为二叉树的结点数，i是二叉树某结点在数组tree中的下标（初始值为1），b为要建立的链式存储二叉树结点指针。转化时，首先建立*b结点，将tree[i]的值赋给*b的数据域，再调用递归函数分别构造左子树和右子树。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、实验目的（1分）1理解二叉树的定义、性质、存储结构等基本概念，掌握二叉树类的设计方法，以及遍历、插入、删除等二叉树操作的算法实现；掌握采用链式存储结构表达非线性结构的设计方法；掌握采用递归算法实现递归数据结构基本操作的设计方法。
2熟悉树的定义、表示、存储结构和遍历，具备使用树各种操作的能力。
二、实验内容（1）在一棵二叉链表表示的二叉树中，实现以下操作，并说明采用哪种遍历算法，其他遍历算法是否可行。
①输入叶子结点。
②求二叉树中叶子结点个数。
③将每个结点的左子树与右子树交换。
④验证二叉树的性质3：n0=n2+1。
⑤输出值大于k的结点。
⑥已知先根和中根次序遍历序列构造二叉树。
⑦以广义表表示构造二叉树。
⑧判断两颗二叉树是否相等。
⑨求结点所在的层次。
⑩求一颗二叉树在后根次序遍历下第一个访问的结点。
⑪复制一颗二叉树。
⑫判断一颗二叉树是否为完全二叉树。
⑬实现二叉树后根次序遍历的非递归算法。
（2）声明三叉链表表示的二叉树类，实现二叉树的基本操作以及以下操作。
①构造一颗三叉链表表示的二叉树。
②返回指定结点的父母结点。
③返回指定结点的所有祖先结点。
④返回两结点最近的共同祖先结点。
（3）在一颗中序线索二叉树中，实现以下操作。
①调用求结点的前驱结点算法，按中根次序遍历一颗中序线索二叉树。
②按后根次序遍历中序线索二叉树。
③在构造二叉树时进行线索化。
④插入、删除操作。
三、实验步骤与结果（3分）第二题的运行结果：四、源码（2分）第一题主类源码：public static void main(String[] args) {String a[] = { "A", "B", "D", null, "G", null, null, null, "C", "E", null, null, "F", "H" };String b[] = { "A", "B", "D", null, null, null, "C", "E", null, null, "F", "H" };Num1<String> tree = new Num1<String>(a);Num1<String> tree1 = new Num1<String>(b);System.out.print("第一题第1个问题：\n");tree.preOrder0();System.out.print("编译错误！");System.out.print("\n" + "第一题第2个问题：\n");System.out.print("编译错误！\n");System.out.print("\n" + "第一题第3个问题：\n");tree.transfer();System.out.println("二叉树左子树和右子数交换后以广义表表示：" +tree.toGenlist());System.out.print("\n" + "第一题第4个问题：\n");tree.judge();System.out.print("\n" + "第一题第5个问题：\n");tree.k = "C";System.out.print("令 k = C \n");tree.printout();System.out.println();System.out.print("\n" + "第一题第7个问题：\n");System.out.println("二叉树 a 以广义表表示：" + tree.toGenlist());System.out.print("\n" + "第一题第8个问题：\n");System.out.println("比较两个二叉树是否相等：" + pare(tree1));System.out.print("\n" + "第一题第9个问题：\n");yer("G", 0);System.out.print("\n" + "第一题第10个问题：\n");tree.firstpoint();System.out.print("\n" + "第一题第11个问题：\n");System.out.println("二叉树tree1，其广义表表示为：" + tree1.toGenlist());tree.y = 0;tree1 = tree.copy();System.out.println("将二叉树tree复制给二叉树tree1，其广义表表示为：" + tree1.toGenlist());System.out.print("\n" + "第一题第12个问题：\n");System.out.println(tree.judgeComplete());System.out.print("\n" + "第一题第13个问题：\n");tree.inOrderTraverse();System.out.println();}}第二题主类源码：public static void main(String[] args) {String a[] = { "A", "B", "D", null, "G", null,"I", null, "C", "E",null, null, "F", "H" };Num2<String> tree = new Num2<String>(a);System.out.print("第二题第一个问题：\n");System.out.print("输出构造的三叉链表：");int i = 0;while(i<14) {System.out.print(a[i]+" ");i++;}System.out.print("\n\n" + "第二题第二个问题：\n");tree.returnparent("B");System.out.print("\n" + "第三题第三个问题：\n");System.out.print("返回指定结点 I 的所有祖先结点：");tree.returnallparent("I");System.out.println();System.out.print("\n" + "第三题第四个问题：\n");tree.returnsameparent("F", "H");}第三题主类源码：public static void main(String[] args) {String a[] = { "A", "B", "D", null, "G", null, null, null, "C", "E", null, null, "F", "H" };Num3<String> tree = new Num3<String>(a);System.out.println("第三题第一个问题：");tree.inOrder();System.out.print("\n\n" + "第三题第二个问题：\n");ttervisit();System.out.print("\n\n" + "第三题第三个问题：没能做出！\n");System.out.print("\n\n" + "第三题第四个问题：\n");System.out.print("\n" + "插入操作：\n");tree.insertChild("B", "X", true);tree.inOrder();System.out.print("\n删除操作：\n");tree.removeLeftChild("C");tree.inOrder();tree.removeRightChild("C");tree.inOrder();}五、结论与讨论（2分）这次试验题目比较多虽然有些题目可以从书上找到，但是由于对课本不是很了解也做了很长时间，这次的实验题目较多。
因此涵盖了本章的所有重要内容，看到实验有点不知所措，不知从何做起，通过小组讨论，看课本，终于有点懵懂。
我们小组现在一些数据结构的安排还做得不够好，努力呀。
经过无尽的努力终于把实验做完了，怎么说呢，这次的实验也很难，也可以说整个数据结构的实验都很难，但是我们会努力把它学好的，加油、努力。
总结出来的心得就是：看书+上机+上机+上机=你才会写代码。