《数据结构》实验1实验报告

合集下载

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。

在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。

我们先来介绍一下顺序表的基本概念。

顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。

顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。

在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。

我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。

在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。

总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。

《数据结构》实验报告模板(附实例)--实验一线性表的基本操作实现

《数据结构》实验报告模板(附实例)--实验一线性表的基本操作实现

《数据结构》实验报告模板(附实例)---实验一线性表的基本操作实现实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现,其中以熟悉各种链表的操作为重点。

2、巩固高级语言程序设计方法与技术,会用线性链表解决简单的实际问题。

二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书,提前做好实验预习与准备工作。

2、加“*”题目必做,其他题目任选;多选者并且保质保量完成适当加分。

3、严格按照数据结构实验报告模板和规范,及时完成实验报告。

四、实验步骤(说明:依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作(成员函数)的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码)㈠、数据结构与核心算法的设计描述(程序中每个模块或函数应加注释,说明函数功能、入口及出口参数)1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释,说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释,说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针,返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针,本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计(可用函数的调用关系图说明)㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图:2、程序清单(程序过长,可附主要部分)说明:以后每次实验报告均按此格式书写。

数据结构实验报告

数据结构实验报告

数据结构实验报告
本次数据结构实验的任务主要包括两部分,分别是学习使用链表数据结构和掌握链表排序算法。

在此基础上,我们完成了一组关于链表基本操作和排序算法的实验。

实验一:链表基本操作
在这个实验中,我们学习了链表的插入、删除、查找等基本操作。

链表的插入和删除操作是通过一个链表节点来实现的。

链表节点包括一个数据域和一个指向下一个节点的指针域。

通过修改指针域,我们就可以实现节点的插入和删除操作。

具体来说,我们编写了一个基本的链表程序,其中包括链表头指针初始化、链表节点插入、链表节点删除、查找指定节点等操作。

通过对程序的调试和功能测试,我们验证了链表操作的正确性。

实验二:链表排序算法
在这个实验中,我们学习了链表排序算法,并编写了链表的快速排序和归并排序两种算法。

快速排序是一种分治思想的排序算法,通过选择一个基准元素,分别将小于和大于基准元素的元素分别放在它的左右两边,再递归地对左右两个子序列进行排序,最终得到有序序列。

归并排序是另一种经典的排序算法,它利用归并思想,将两个有序序列合并成一个更大的有序序列,这个过程不断重复,最终得到完整的有序序列。

通过实现这两种排序算法,并在大样本数据下进行测试,我们验证了算法的正确性和效率。

实验总结:
通过本次实验,我们深入学习了链表数据结构的相关基本操作和排序算法的实现原理。

同时,在实际编程实践中,我们也掌握了链表程序的调试、测试和优化技术。

这些都是我们今后从事软件开发工作需要掌握的重要技能,在这个方面的积累将会对我们有很大帮助。

《数据结构》课程实验报告一

《数据结构》课程实验报告一

《数据结构》课程实验报告一线性表的顺序实现一、实验目的和要求:1.掌握顺序表的存储结构形式及其描述和基本运算的实现。

2.掌握用顺序表表示集合等数据的方法,并能设计出合理的存储结构,编写出有关运算的算法。

二、实验内容:(给出具体的说明文字和操作图片)已知顺序表结构与相关函数定义在sequlist.h文件中,基于该文件完成所有实验题。

1.基于sequlist.h中定义的顺序表L,设计一个算法voiddelx(sequence_list *L, datatype x),删除其中所有值等于x 的元素,要求算法的时间复杂度为O(n)、空间复杂度为0(1)。

#include <stdio.h>#include <stdlib.h>#include <malloc.h>/**********************************//*顺序表的头文件,文件名sequlist.h*//**********************************/#define MAXSIZE 100typedef int datatype;typedef struct{datatype a[MAXSIZE];//存放数组a的第一个地址int size;//长度}sequence_list;//请将本函数补充完整,并进行测试//void initseqlist(sequence_list *L)//初始化OK{L->size=0;}void input(sequence_list *L){datatype x;initseqlist(L);printf("请输入一组数据,以0做为结束符:\n"); scanf("%d",&x);while (x){L->a[L->size++]=x;scanf("%d",&x);}}void delx(sequence_list *L,datatype x) {int i,j;j=0;for( i=0;i<L->size;i++){if(L->a[i]!=x){if(j<i){L->a[j]=L->a[i];}j++;}}L->size=j;//最后数组的长度}void print(sequence_list *L){int i;for (i=0;i<L->size;i++){printf("%d\t",L->a[i]);//if ((i+1)%10==0) printf("\n");}printf("\n");}int main(){int x;sequence_list L; //定义顺序表*/ input(&L);printf("\n"); //输入测试用例// print(&L); //输出原表// printf("请输入要删除的元素值:");scanf("%d",&x);delx(&L,x);// 删除所有值等于x的值//print(&L);return 0; //输出新表//}2.基于sequlist.h中定义的顺序表,编写算法函数reverse(sequence_list *L),实现顺序表的倒置。

数据结构实验报告

数据结构实验报告

实验一单链表的实现与应用一、实验目的掌握单链表的基本操作和设计数据测试功能的方法。

二、实验要求1)设数据元素的数据类型为int类型,编写一个逐个输出单链表中所有数据元素的算法。

2)设计循环单链表,要求包括初始化、求数据元素个数、插入、删除和取数据元素,并设计测试主函数验证其正确性。

三、实验仪器设备及软件HP D538、C语言四、实验原理单链表是一种最基础的链式存储结构,链式表不要求使用连续的存储空间来存储元素,它是通过连接的方式,来将不连续的物理空间连接成一条链式的逻辑上是相邻的结构。

对链式表进行插入,删除等操作就不需要移动元素了,只需要改变指针的指向,这样大大提高了效率。

1)单链表单链表基本组成是节点,节点里面有要存储的数据单元和指向下一节点的指针,他的基本操作主要有初始化、插入、删除、打印单链表、销毁单链表等。

a)链表的初始化初始化链表是初始化了一个表头元素,表头元素不是第一个节点元素,而是一个节点的指针。

b)链表插入在链表指定节点a和b之间插入新节点c,首先创建一个节点c,然后将c的指针指向b,再将a的指针指向c即可。

插入操作一定要注意顺序。

c)删除操作删除相邻节点a、b、c之间的b节点。

首先创建指针ptrb,指向b节点;然后将将a中的指针指向c节点,最后free掉指针ptrb所指向的b节点。

d)打印链表通过循环对链表进行遍历,输出遍历过程中所有的数据元素即可。

e)销毁链表遍历链表,其过程中通过指针指向节点,按顺序free掉节点即可。

2)循环链表循环链表不同于单链表之处是,循环链表不存在头结点,是节点按照首尾相接组成的,要遍历循环链表必须制定他的长度,否则很可能陷入无限循环。

循环链表大部分操作与单链表相同,不再重复。

不同于单链表的操作主要有链表的打印输出、销毁等需要遍历链表的操作。

具体解决方法是:把判断尾节点的指针域为NULL变为是否是头节点。

五、实验步骤及程序1)实验步骤a)打开IDE,新建工程文件,添加头文件和.c文件。

数据结构课程设计实验1_城市链表

数据结构课程设计实验1_城市链表

数据结构课程设计实验报告实验一链表部分选题为:2.4.3—城市链表1、需求分析(1)创建一个带有头结点的单链表。

(2)结点中应包含城市名和城市的位置坐标。

(3)对城市链表能够利用城市名和位置坐标进行有关查找、插入、删除、更新等操作。

(4)能够对每次操作后的链表动态显示。

2、概要设计为了实现以上功能,可以从以下3个方面着手设计。

(1)主界面设计为了实现城市链表相关操作功能的管理,设计一个含有多个菜单项的主控菜单子程序以系统的各项子功能,方便用户使用本程序。

本系统主控菜单运行界面如下所示。

(2)存储结构设计本系统主要采用链表结构类型来表示存储在“城市链表”中的信息。

其中链表结点由4个分量组成:城市名name、城市的横坐标posx、城市的纵坐标posy、指向下一个结点的指针next。

(3)系统功能设计本程序设计了9个功能子菜单,其描述如下:①建立城市链表。

由函数creatLink()实现。

该功能实现城市结点的输入以及连接。

②插入链表记录。

由函数insert()实现。

该功能实现按坐标由小到大的顺序将结点插入到链表中。

③查询链表记录。

由searchName()函数和searchPos()函数实现。

其中searchName()实现按照城市名查询的操作,searchPos()实现按照城市坐标查询的操作。

④删除链表记录。

由delName()函数和delPos()函数实现。

其中delName()函数实现按照城市名删除的操作,delPos()函数实现按照城市坐标删除的操作。

⑤ 显示链表记录。

由printList ()函数实现。

该功能实现格式化的链表输出操作,可以显示修改后的链表状态。

⑥ 更新链表信息。

由update ()函数实现。

该功能实现按照城市名更新城市的坐标信息。

⑦ 返回城市坐标。

由getPos ()函数实现。

该功能实现给定一个已存储的城市,返回其坐标信息的操作。

⑧ 查看与坐标P 距离小于等于D 的城市。

由getCity ()函数实现。

《数据结构》实验1实验报告

《数据结构》实验1实验报告

南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。

一、实验目的1.熟悉上机环境,进一步掌握语言的结构特点。

2.掌握线性表的顺序存储结构的定义及实现。

3.掌握线性表的链式存储结构——单链表的定义及实现。

4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。

5.掌握线性表在链式存储结构——单链表中的各种基本操作。

二、实验内容1.顺序线性表的建立、插入及删除。

2.链式线性表的建立、插入及删除。

三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

2.利用前面的实验先建立一个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插入元素68。

3.建立一个带头结点的单链表,结点的值域为整型数据。

要求将用户输入的数据按尾插入法来建立相应单链表。

四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长:{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素:");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素:", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据:\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获,体会及问题(写得越详细、越个性化、越真实越好,否则我不知道你做这个实验的心路历程,也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手,才刚上了几节课,对于线性表、链式表都不是理解的很透彻,不知道用哪个软件编写程序。

数据结构实验报告

数据结构实验报告

实验报告题目数据结构实验学生姓名学号系部专业班级指导教师二〇一〇年十二月实验1:顺序表实验一、实验目的:1.学会定义线性表的顺序存储类型,实现C程序的基本结构对线性表的一些基本操作和具体的函数定义。

2.掌握顺序表的基本操作,实现顺序表的插入,删除,查找基本运算。

3.掌握对于多函数程序的输入,编辑,调试和运算过程。

二、实验要求:1.预习C语言中结构体的定义和基本的操作方法。

2.对顺序表每个基本操作用一个单独函数实现。

3.编写完整程序完成下面实验内容并且上机运行。

三、实验内容:编写完整程序完成下面基本操作并且上机运行1.初始化顺序表La;2.将顺序表La设置为空表;3.测试顺序表La是否上空表;4.在顺序表La插入一个新元素;5.删除顺序表La中某个元素;6.在顺序表La中查找某个元素,查找成功,返回位序,否则返回0;7.建立顺序表La;8.打印顺序表La所有元素;10.输入n个元素建立顺序表La;11.归并非递减表La和Lb成为非递减表Lc。

要求编写一个主菜单调用上面各个基本操作。

四、程序体现:#include<stdio.h>#include <conio.h>#include <stdlib.h>#define LIST_INIT_SIZE 10#define LISTINCREMENT 3#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#define Null 0typedef int status;typedef int elemtype;typedef struct {int *elem;int length;int listsize;}sqlist;status InitList(sqlist &L){L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));if(!L.elem)exit(OVERFLOW);L.length=10;L.listsize=LIST_INIT_SIZE;return OK;}status ClearList(sqlist &L){L.elem=Null;return OK;}status TestList(sqlist &L){if(L.elem=Null)return TRUE;elsereturn FALSE;}status ListInsert(sqlist &L,int i,int e){printf("经修改后,链表为:");int *p,*q;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){int *newbase;newbase=(int *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}status ListDelete(sqlist &L,int i,elemtype &e){ elemtype *q, *p;if((i<1)||(i>L.length))return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return OK;}int LocateElem(sqlist L,int e){int i = 0;for (i = 0; i < L.length; i++){if (L.elem[i] == e)return i + 1;}return FALSE;}void MergeList(sqlist L1,sqlist L2,sqlist &L3){printf("经合并后的新表为:");int *pa,*pb,*pc,*pa_last,*pb_last;pa=L1.elem;pb=L2.elem;L3.listsize=L3.length=L1.length+L2.length;pc=L3.elem=(int *)malloc(L3.listsize*sizeof(int));if(!L3.elem)exit(OVERFLOW);pa_last=L1.elem+L1.length-1;pb_last=L2.elem+L2.length-1;while(pa<=pa_last&&pb<=pb_last){if(*pa<=*pb)*pc++=*pa++;else *pc++=*pb++;}while(pa<=pa_last)*pc++=*pa++;while(pb<=pb_last)*pc++=*pb++;}void main(){sqlist La,Lb,Lc;int i,j,m,n,p,q,s,r;printf("创建一个新的线性表,请输入十个数字:");InitList(La);for(i=0;i<LIST_INIT_SIZE;i++)scanf("%d",&La.elem[i]);for(i=0;i<LIST_INIT_SIZE;i++)printf("%d ",La.elem[i]);printf("\n");printf("现插入一个数据,请输入它的位数和大小:");int a,b;scanf("%d%d",&a,&b);ListInsert(La,a,b);for(s=0;s<La.length;s++)printf("%d ",La.elem[s]);printf("\n");printf("现删除一个数据,请输入它的位数和大小:");int c,d;scanf("%d%d",&c,&d);ListDelete(La,c,d);for(j=0;j<La.length;j++)printf("%d ",La.elem[j]);printf("\n");printf("现查找一个数据,请输入它的位数:");int e;scanf("%d",&e);n=LocateElem(La,e);printf("n=%d",n);printf("再次创建一个新表.");InitList(Lb);for(q=0;q<LIST_INIT_SIZE;q++)scanf("%d ",&Lb.elem[q]);printf("\n");printf("现将两个线性表进行合并...");printf("\n");MergeList(La,Lb,Lc);for(r=0;r<2*LIST_INIT_SIZE;r++)printf("%d ",Lc.elem[r]);printf("\n");printf("测试线性表La是否为空,如果返回值为1,则为空:");m=TestList(La);printf("m=%d",m);printf("\n");printf("现将线性表La置为空,如果返回值为1,则置空成功.");p=ClearList(La);printf("p=%d",p);printf("\n");printf("The End!");}实验2:单链表实验一、实验目的:1.学会定义线性表的链表存储类型,实现C程序的基本结构对线性表的一些基本操作和具体的函数定义。

数据结构实验报告1-线性结构的顺序存储

数据结构实验报告1-线性结构的顺序存储
评定等级为:优秀、良好、中等、及格、不及格
教师签名: 2008 年 月 日
第2页共2页
2、参照课本,定义一个向量类模板,编写它的成员函数模板,对类模板加以实现;编写向量的并、 交运算功能函数;编写主程序,对两个向量进行分别进行合并、交运算。
3、通过阅读课本栈类板代码,理解栈类操作特点;编写一个借助于栈,将二进制数转换为十进制数 字串的程序;编写汉诺塔问题程序,理解函数的递归调用。
4、参照课本,定义一个顺序队列类模板,编写它的成员函数模板 ,对类模板加以实现;编写主程序, 对队列进行各种基本操作,理解队列的操作特性。
五、 实验总结(包括心得体会、问题回答及实验改进意见,可附页)
通过本次实验,基本上能够理解线性结构的顺序存储方式及各种不同线性结构的操作方式;顺序存 储方式主要用于线性的数据结构,它把逻辑上相邻的数据元素存储在物理上相邻的存储单元里结点之间 的关系由存储单元的邻接关系来体现。线性表、向量、栈、队列都属于线性结构的顺序存储,各结点的 物理地址是相邻的,每一次插入、删除运算会引起相应结点物理地址的重新排列;栈的操作特点是先进 后出,而队列的操作特点是先进先出。
2、 对两个向量进行合并、交运算,结果如下: 输入向量 La 的结点元素:1 2 3 4 5,输入 Lb 的结点元素:1 2 3 4 5 6,则两向量的交集为:1 2 3 4 5;并集为:1 2 3 4 5 6。
3、(1)将二进制数转换为十进制数字串的程序,结果如下: 输入要转换的带符号整数 x:+3;则 x 转换成十进制数字串输出为:+3
Байду номын сангаас
第1页共2页
四、 实验结果(包括程序或图表、结论陈述、数据记录及分析等,可附页)
1、 对线性表进行插入、删除、定位等操作,结果如下: 输入线性表元素:1 2 3 4 5,(1)选择插入,输入插入位置 2,插入值 9,则新的线性表为:1 2 9 3 4 5;(2)选择删除,输入删除元素序号 5,则新的线性表为:1 2 9 3 4;(3)选择取值,输入要求 值元素序号 2,则屏幕输出:第2个元素的值为 9;(4)选择查找,输入要查找的元素值 9,则屏幕输 出:要查找元素的序号为 2。

数据结构实验一实验报告

数据结构实验一实验报告

班级:姓名:学号:实验一线性表的基本操作一、实验目的1、掌握线性表的定义;2、掌握线性表的基本操作,如成立、查找、插入和删除等。

二、实验内容定义一个包括学生信息(学号,姓名,成绩)的次序表和链表(二选一),使其拥有以下功能:(1)依据指定学生个数,逐一输入学生信息;(2)逐一显示学生表中全部学生的有关信息;(3)依据姓名进行查找,返回此学生的学号和成绩;(4)依据指定的地点可返回相应的学生信息(学号,姓名,成绩);(5)给定一个学生信息,插入到表中指定的地点;(6)删除指定地点的学生记录;(7)统计表中学生个数。

三、实验环境Visual C++四、程序剖析与实验结果#include<>#include<>#include<>#include<>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;结构链表");puts("2. 录入学生信息 ");puts("3. 显示学生信息 ");puts("4. 输入姓名,查找该学生");puts("5. 显示某地点该学生信息");puts("6. 在指定地点插入学生信息");puts("7. 在指定地点删除学生信息");puts("8. 统计学生个数 ");puts("0. 退出 ");printf("\n********************************\n\n");int x,choose=-1;while(choose!=0){puts(" 请选择 :");scanf("%d",&choose);switch(choose){case 1:if(InitList(p))printf(" 成功成立链表 \n\n");elseprintf(" 链表成立失败 \n\n");break;case 2:printf(" 请输入要录入学生信息的人数:");scanf("%d",&x);for(int i=1;i<=x;i++){printf(" 第%d个学生 :\n",i);Input(&a);ListInsert(&L,i,a);}break;case 3:for(int i=1;i<=x;i++){GetElem(&L,i,b);Output(&b);}break;case 4:char s[20];printf(" 请输入要查找的学生姓名:");scanf("%s",s);if(Search(L,s,p))Output(&(p->data));elseputs(" 对不起,查无这人 ");puts("");break;case 5:printf(" 请输入要查问的地点 :");int id1;scanf("%d",&id1);GetElem(&L,id1,c);Output(&c);break;case 6:printf ("请输入要插入的地点:");int id2;scanf("%d",&id2);printf(" 请输入学生信息 :\n");Input(&d);if(ListInsert(&L,id2,d)){x++;puts(" 插入成功 ");puts("");}else{puts(" 插入失败 ");puts("");}break;case 7:printf(" 请输入要删除的地点 :");int id3;scanf("%d",&id3);if(ListDelete(&L,id3)){x--;puts(" 删除成功 ");puts("");}else{puts(" 删除失败 ");puts("");}break;case 8:printf(" 已录入的学生个数为 :%d\n\n",x);break;}}printf("\n\n感谢您的使用,请按随意键退出\n\n\n");system("pause");return 0;}用户界面 :(1)依据指定学生个数,逐一输入学生信息:(2)逐一显示学生表中全部学生的有关信息:(3)依据姓名进行查找,返回此学生的学号和成绩:(4) 依据指定的地点可返回相应的学生信息(学号,姓名,成绩):(5)给定一个学生信息,插入到表中指定的地点:(6)删除指定地点的学生记录:(7)统计表中学生个数:五、实验总结数据结构是一门专业技术基础课。

数据结构上机实验报告

数据结构上机实验报告

数据结构实验报告课程数据结构 _ 院系专业班级实验地点姓名学号实验时间指导老师数据结构上机实验报告1一﹑实验名称:实验一——链表二﹑实验目的:1.了解线性表的逻辑结构特性;2.熟悉链表的基本运算在顺序存储结构上的实现,熟练掌握链式存储结构的描述方法;3.掌握链表的基本操作(建表、插入、删除等)4. 掌握循环链表的概念,加深对链表的本质的理解。

5.掌握运用上机调试链表的基本方法三﹑实验内容:(1)创建一个链表(2)在链表中插入元素(3)在链表中删除一个元素(4)销毁链表四﹑实验步骤与程序#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的链表均为带头结点。

void CreatLinkList(LinkList &L,int j){//建立一个链表L,数据为整数,数据由键盘随机输入。

LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"请输入一个链表:"<<endl;for(int i=0;i<j;i++){ p=(LinkList)malloc(sizeof(Lnode));cin>>p->data;p->next=q->next;q->next=p;q=p;}}int PrintLinkList(LinkList &L){//输出链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算链表L的数据元素个数。

数据结构实验报告(一)线性表的应用

数据结构实验报告(一)线性表的应用

数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。

⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。

要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。

2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。

要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。

如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。

(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。

(3)当给定x的值时,能计算表达式相加或相减的结果。

(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。

(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。

实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。

2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。

(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。

因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。

综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。

3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。

(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。

(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。

数据结构实验报告实验1

数据结构实验报告实验1

数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见的数据结构,如线性表、栈、队列等,并能够运用所学知识解决实际问题。

二、实验环境本次实验使用的编程环境为Visual Studio 2019,编程语言为C++。

三、实验内容与步骤(一)线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。

实现插入、删除、查找等基本操作。

2、链表的实现定义链表节点结构体,包含数据域和指针域。

实现链表的创建、插入、删除、遍历等操作。

(二)栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。

实现入栈、出栈、栈顶元素获取等操作。

2、栈的应用利用栈实现表达式求值。

(三)队列的实现与应用1、队列的实现使用循环数组或链表实现队列。

实现入队、出队、队头元素获取等操作。

2、队列的应用模拟银行排队系统。

四、实验结果与分析(一)线性表1、顺序表插入操作:在指定位置插入元素时,需要移动后续元素,时间复杂度为 O(n)。

删除操作:删除指定位置的元素时,同样需要移动后续元素,时间复杂度为 O(n)。

查找操作:可以直接通过索引访问元素,时间复杂度为 O(1)。

2、链表插入操作:只需修改指针,时间复杂度为 O(1)。

删除操作:同样只需修改指针,时间复杂度为 O(1)。

查找操作:需要遍历链表,时间复杂度为 O(n)。

(二)栈1、表达式求值能够正确计算简单的四则运算表达式,如 2 + 3 4。

对于复杂表达式,如(2 + 3) 4,也能得到正确结果。

(三)队列1、银行排队系统模拟了客户的到达、排队和服务过程,能够反映出队列的先进先出特性。

五、实验中遇到的问题及解决方法(一)线性表1、顺序表的空间浪费问题问题描述:当预先分配的空间过大而实际使用较少时,会造成空间浪费。

解决方法:可以采用动态分配空间的方式,根据实际插入的元素数量来调整存储空间。

2、链表的指针操作错误问题描述:在链表的插入和删除操作中,容易出现指针指向错误,导致程序崩溃。

数据结构实验一(完整版)

数据结构实验一(完整版)

数据结构实验一:线性表实验报告#include <string.h>#include <ctype.h>#include <malloc.h> // malloc()等#include <limits.h> // INT_MAX等#include <stdio.h> // EOF(=^Z或F6),NULL#include <stdlib.h> // atoi()#include <io.h> // eof()#include <math.h> // floor(),ceil(),abs()#include <process.h> // exi t()#include <iostream.h> // cout,cin// 函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSEtypedef int ElemType;#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LISTINCREMENT 2 // 线性表存储空间的分配增量struct SqListElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)};/**********************************************************/ /* 顺序表示的线性表的基本操作(12个) *//**********************************************************/ Status InitList(SqList &L){ // 操作结果:构造一个空的顺序线性表---------------1L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量return OK;}Status DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。

(完整版)数据结构实验报告全集

(完整版)数据结构实验报告全集

数据结构实验报告全集实验一线性表基本操作和简单程序1.实验目的(1)掌握使用Visual C++ 6.0上机调试程序的基本方法;(2)掌握线性表的基本操作:初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。

2.实验要求(1)认真阅读和掌握和本实验相关的教材内容。

(2)认真阅读和掌握本章相关内容的程序。

(3)上机运行程序。

(4)保存和打印出程序的运行结果,并结合程序进行分析。

(5)按照你对线性表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果实验代码:1)头文件模块#include iostream.h>//头文件#include<malloc.h>//库头文件-----动态分配内存空间typedef int elemtype;//定义数据域的类型typedef struct linknode//定义结点类型{elemtype data;//定义数据域struct linknode *next;//定义结点指针}nodetype;2)创建单链表nodetype *create()//建立单链表,由用户输入各结点data域之值,//以0表示输入结束{elemtype d;//定义数据元素dnodetype *h=NULL,*s,*t;//定义结点指针int i=1;cout<<"建立一个单链表"<<endl;while(1){cout <<" 输入第"<< i <<"结点data域值:";cin >> d;if(d==0) break;//以0表示输入结束if(i==1)//建立第一个结点{h=(nodetype*)malloc(sizeof(nodetype));//表示指针hh->data=d;h->next=NULL;t=h;//h是头指针}else//建立其余结点{s=(nodetype*) malloc(sizeof(nodetype));s->data=d;s->next=NULL;t->next=s;t=s;//t始终指向生成的单链表的最后一个节点}i++;}return h;}3)输出单链表中的元素void disp(nodetype*h)//输出由h指向的单链表的所有data域之值{nodetype *p=h;cout<<"输出一个单链表:"<<endl<<" ";if(p==NULL)cout<<"空表";while(p!=NULL){cout<<p->data<<" ";p=p->next;}cout<<endl;}4)计算单链表的长度int len(nodetype *h)//返回单链表的长度{int i=0;nodetype *p=h;while(p!=NULL){p=p->next;i++;}return i;}5)寻找第i个节点nodetype *find(nodetype *h,int i)//返回第i个节点的指针{nodetype *p=h;int j=1;if(i>len(h)||i<=0)return NULL;//i上溢或下溢celse{while (p!=NULL&&j<1)//查找第i个节点,并由p指向该节点{j++;p=p->next;}return p;} }6)单链表的插入操作nodetype *ins(nodetype *h,int i,elemtype x)//在单链表head中第i个节点//(i>=0)之后插入一个data域为x的节点{nodetype *p,*s;s=(nodetype*)malloc(sizeof(nodetype));//创建节点ss->data=x;s->next=NULL;if(i==0)//i=0:s作为该单链表的第一个节点{s->next=h;h=s;}else{p=find(h,i);//查找第i个节点,并由p指向该节点if(p!=NULL){s->next=p->next;p->next=s;}return h;}}7)单链表的删除操作nodetype *del(nodetype *h,int i)//删除第i个节点{nodetype *p=h, *s;int j=1;if(i==1)//删除第1个节点{h=h->next;free(p);}else{p=find(h,i-1);//查找第i-1个节点,并由p指向该节点 if(p!=NULL&&p->next!=NULL){s=p->next;//s指向要删除的节点p->next=s->next;free(s);}else cout<<"输入i的值不正确"<<endl;}return h;}8)释放节点空间void dispose(nodetype *h)//释放单链表的所有节点占用的空间{nodetype *pa=h,*pb;if(pa!=NULL){pb=pa->next;if(pb==NULL)//只有一个节点的情况free(pa);else{while (pb!=NULL)//有两个及以上节点的情况{free(pa);pa=pb;pb=pb->next;}free(pa);}}}9)主程序模块:#include"slink.h"//包含头文件slinkvoid main(){nodetype *head;//定义节点指针变量head=create();//创建一个单链表disp(head);//输出单链表cout<<"单链表长度:"<<len(head)<<endl;ins(head, 2,0);//在第二个节点之后插入以0为元素的节点 disp(head);//输出新链表del(head,2);//删除第二个节点disp(head);//输出新链表}5.实验结果建立一个单链表:输入第1结点data域值:1输入第2结点data域值:2输入第3结点data域值:3输入第4结点data域值:4输入第5结点data域值:5输入第6结点data域值:6输入第7结点data域值:7输入第8结点data域值:8输入第9结点data域值:9输入第10结点data域值0:输出一个单链表:1 2 3 4 5 6 7 8 9单链表长度:9输出一个单链表:1 02345678 9输出一个单链表:1 2 3 4 5 6 7 8实验二顺序栈的实现1.实验目的掌握顺序栈的基本操作:初始化栈、判栈空否、入栈、出栈、取栈顶数据元素等运算以及程序实现方法。

数据结构实验报告1线性表的顺序存储结构

数据结构实验报告1线性表的顺序存储结构

数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解线性表的顺序存储结构,并通过编程实现其基本操作,包括创建线性表、插入元素、删除元素、查找元素以及输出线性表等。

通过实际操作,掌握顺序存储结构的特点和优势,同时也了解其在不同情况下的性能表现。

二、实验环境本次实验使用的编程语言为C++,编译环境为Visual Studio 2019。

三、实验原理1、线性表的定义线性表是由 n(n≥0)个数据元素组成的有限序列。

在顺序存储结构中,线性表的元素存储在一块连续的存储空间中,通过数组来实现。

2、顺序存储结构的特点存储密度高,无需额外的指针来表示元素之间的关系。

可以随机访问表中的任意元素,时间复杂度为 O(1)。

插入和删除操作需要移动大量元素,平均时间复杂度为 O(n)。

四、实验内容及步骤1、定义线性表的数据结构```cppdefine MAX_SIZE 100 //定义线性表的最大长度typedef struct {int dataMAX_SIZE; //存储线性表元素的数组int length; //线性表的当前长度} SeqList;```2、初始化线性表```cppvoid InitList(SeqList L) {L>length = 0; //初始时线性表长度为 0}```3、判断线性表是否为空```cppbool ListEmpty(SeqList L) {return (Llength == 0);}```4、求线性表的长度```cppint ListLength(SeqList L) {return Llength;}```5、按位查找操作```cppint GetElem(SeqList L, int i) {if (i < 1 || i > Llength) {printf("查找位置不合法!\n");return -1;}return Ldatai 1;}```6、按值查找操作```cppint LocateElem(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}return 0; //未找到返回 0}```7、插入操作```cppbool ListInsert(SeqList L, int i, int e) {if (L>length == MAX_SIZE) {//表已满printf("表已满,无法插入!\n");return false;}if (i < 1 || i > L>length + 1) {//插入位置不合法printf("插入位置不合法!\n");return false;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;//表长加 1return true;}```8、删除操作```cppbool ListDelete(SeqList L, int i) {if (L>length == 0) {//表为空printf("表为空,无法删除!\n");return false;}if (i < 1 || i > L>length) {//删除位置不合法printf("删除位置不合法!\n");return false;}for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length; //表长减 1return true;}```9、输出线性表```cppvoid PrintList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```10、测试用例```cppint main(){SeqList L;InitList(&L);ListInsert(&L, 1, 10);ListInsert(&L, 2, 20);ListInsert(&L, 3, 30);ListInsert(&L, 4, 40);ListInsert(&L, 5, 50);printf("线性表的长度为:%d\n", ListLength(L));printf("查找第 3 个元素:%d\n", GetElem(L, 3));int loc = LocateElem(L, 30);if (loc) {printf("元素 30 的位置为:%d\n", loc);} else {printf("未找到元素 30\n");}ListDelete(&L, 3);printf("删除第 3 个元素后的线性表:");PrintList(L);return 0;}```五、实验结果及分析1、实验结果成功创建并初始化了线性表。

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

南京工程学院实验报告
<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。

一、实验目的
1. 掌握查找的不同方法,并能用高级语言实现查找算法;
2. 熟练掌握二叉排序树的构造和查找方法。

3. 了解静态查找表及哈希表查找方法。

二、实验内容
设计一个算法读入一串整数,然后构造二叉排序树,进行查找。

三、实验步骤
1. 从空的二叉树开始,每输入一个结点数据,就建立一个新结点插入到当前已生成的二叉排序树中。

2. 在二叉排序树中查找某一结点。

3.用其它查找算法进行排序。

四、程序主要语句及作用
程序1的主要代码
public class BinarySearchTreeNode //二叉查找树结点
{
public int key;
public BinarySearchTreeNode left;
public BinarySearchTreeNode right;
public BinarySearchTreeNode(int nodeValue)
{
key = nodeValue;
left = null;
right = null;
}
public void InsertNode(BinarySearchTreeNode node)//插入结点 {
if (node.key > this.key)
{
if (this.right == null)
{
this.right = node;
return;
}
else
this.right.InsertNode(node);
}
else
{
if (this.left == null)
{ this.left = node; return; }
else
this.left.InsertNode(node);
}
}
public bool SearchKey(int searchValue)
{
if (this.key == searchValue)
return true;
if (searchValue > this.key)
{
if (this.right == null)
return false;
else
return this.right.SearchKey(searchValue);
}
else
{
if (this.left == null)
return false;
else
return this.left.SearchKey(searchValue);
}
}
public void MiddleOrder()
{
if (this.left != null)
this.left.MiddleOrder();
Console.WriteLine(this.key);
if (this.right != null)
this.right.MiddleOrder();
}
public void PreOrder()
{
Console.WriteLine(this.key);
if (this.left != null)
this.left.PreOrder();
if (this.right != null)
this.right.PreOrder();
}
public void PostOrder()
{
if (this.left != null)
this.left.PostOrder();
if (this.right != null)
this.right.PostOrder();
Console.WriteLine(this.key);
}
} //二叉查找树结点
public class BinarySearchTree//二叉查找树
{
private BinarySearchTreeNode root;
public BinarySearchTree()
{ root = null; }
public BinarySearchTree(int nodeValue)
{ root = new BinarySearchTreeNode(nodeValue); }
public void InsertBinarySearchTreeNode(int nodeValue) {
BinarySearchTreeNode insertNode = new
BinarySearchTreeNode(nodeValue);
if (root == null)
{ root = insertNode; return; }
else
{ root.InsertNode(insertNode); return; }
}
public bool SearchKey(int searchValue)
{
if (root.key == searchValue) return true;
else
return root.SearchKey(searchValue);
}
public void MidOrder()
{ root.MiddleOrder(); return; }
public void PreOrder()
{ root.PreOrder(); return; }
public void PostOrder()
{ root.PostOrder(); return; }
public static void BinarySearchTreeSort(int[] a)
{
BinarySearchTree t = new BinarySearchTree();
for (int i = 0; i < a.Length; i++)
t.InsertBinarySearchTreeNode(a[i]);
t.MidOrder(); return;
}
public static bool BinarySearchTreeSearch(int[] a, int searchKey) {
BinarySearchTree t = new BinarySearchTree();
for (int i = 0; i < a.Length; i++)
t.InsertBinarySearchTreeNode(a[i]);
return t.SearchKey(searchKey);
}
}//二叉查找树
class Program
{
static void Main(string[] args)
{
BinarySearchTree b = new BinarySearchTree();
b.InsertBinarySearchTreeNode(7);
b.InsertBinarySearchTreeNode(5);
b.InsertBinarySearchTreeNode(13);
b.InsertBinarySearchTreeNode(6);
b.InsertBinarySearchTreeNode(26);
b.InsertBinarySearchTreeNode(18);
Console.WriteLine("排序后:");
b.MidOrder();
// Console.ReadKey();
Console.Write("请输入要查找的数据:");
int searchData = Convert.ToInt32(Console.ReadLine());
if (b.SearchKey(searchData))
Console.WriteLine("找到{0}结点!", searchData);
else
Console.WriteLine("未找到{0}结点!", searchData);
Console.ReadKey();
}
}
}
五、程序运行结果截图
程序1
六、收获,体会及问题(写得越详细、越个性化、越真实越好,否则我不知道你做这个实验的心路历程,也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)。

相关文档
最新文档