数据结构二叉排序树实验报告
数据结构试验报告 二叉排序树的操作
数据结构实验报告班级:信息与计算科学专业1102班学号: 1108060214姓名:朱晓东设计日期:2013.6.6西安科技大学计算机学院1.实验报告编写一个演示运用二叉排序树进行数据的的排序、插入、删除、查找等操作的程序。
2.需求分析本演示程序用vc6.0编写,完成数据的排序功能,同时能够进行数据的创建、插入、删除、查找。
(1)输入的形式和输入值的范围:创建二叉排序树时输入较多的值;插入元素时需要输入插入的元素的值;删除元素时输入元素的值;查找操作时需要输入元素的值。
所有输入中,元素的值都是整数。
(2)输出的形式:在创建、插入、删除的操作后,均显示操作后的元素的排序状况,有小到大排序。
(3)程序所能达到的功能:完成二叉排序树的生成、插入、删除、查找操作。
(4)测试数据:①插入操作中依次输入10 9 11 8 12 0(本程序是以0元素为为结束标志);②查找操作中输入13;③插入操作中输入13;3概要设计本程序包含8个函数:(1)主函数main()(2)创建二叉排序树函数BSTCreate(BiTree* bt)(3)显示操作菜单函数menu()(4)显示二叉排序树的内容函数BSTShow(BiTree bt)(5)插入元素函数BSTInsert(BiTree* bt,DataType key)(6)删除元素函数BSTDelete(BiTree* bt,DataType key)(7)查找元素函数BSTSearch(BiTree bt,DataType key)(8)查找要删除的元素的函数DeleteNode(BiTree* bt)各函数之间的关系如下:BSTCreate(BiTree* bt)menu()BSTShow(BiTree bt)mainBSTInsert(BiTree* bt,DataType key)BSTDelete(BiTree* bt,DataType key) DeleteNode(BiTree* bt)BSTSearch(BiTree bt,DataType key)4.详细设计实现概要设计中定义的所有数据类型,对每个操作给出伪码算法。
数据结构二叉排序树实验报告
实验报告课程名:数据结构(C语言版)实验名:二叉排序树姓名:班级:学号:撰写时间:2014.12.18一实验目的与要求1.掌握二叉排序树上进行插入和删除的操作2.利用 C 语言实现该操作二实验内容•对于一个线形表, 利用不断插入的方法, 建立起一株二叉排序树•从该二叉排序树中删除一个叶子节点, 一个只有一个子树的非叶子节,一个有两个子树的非叶子节点。
三实验结果与分析#include<stdio.h>#include<stdlib.h>//二叉查找树结点描述typedef int KeyType;typedef struct Node{KeyType key; //关键字struct Node * left; //左孩子指针struct Node * right; //右孩子指针struct Node * parent; //指向父节点指针}Node,*PNode;//往二叉查找树中插入结点//插入的话,可能要改变根结点的地址,所以传的是二级指针void inseart(PNode * root,KeyType key){//初始化插入结点PNode p=(PNode)malloc(sizeof(Node));p->key=key;p->left=p->right=p->parent=NULL;//空树时,直接作为根结点if((*root)==NULL){*root=p;return;}//插入到当前结点(*root)的左孩子if((*root)->left == NULL && (*root)->key > key){ p->parent=(*root);(*root)->left=p;return;}//插入到当前结点(*root)的右孩子if((*root)->right == NULL && (*root)->key < key){ p->parent=(*root);(*root)->right=p;return;}if((*root)->key > key)inseart(&(*root)->left,key);else if((*root)->key < key)inseart(&(*root)->right,key);elsereturn;}//查找元素,找到返回关键字的结点指针,没找到返回NULL PNode search(PNode root,KeyType key){if(root == NULL)return NULL;if(key > root->key) //查找右子树return search(root->right,key);else if(key < root->key) //查找左子树return search(root->left,key);elsereturn root;//查找最小关键字,空树时返回NULLPNode searchMin(PNode root){if(root == NULL)return NULL;if(root->left == NULL)return root;else //一直往左孩子找,直到没有左孩子的结点 return searchMin(root->left);}//查找最大关键字,空树时返回NULLPNode searchMax(PNode root){if(root == NULL)return NULL;if(root->right == NULL)return root;else //一直往右孩子找,直到没有右孩子的结点 return searchMax(root->right);//查找某个结点的前驱PNode searchPredecessor(PNode p){//空树if(p==NULL)return p;//有左子树、左子树中最大的那个if(p->left)return searchMax(p->left);//无左子树,查找某个结点的右子树遍历完了 else{if(p->parent == NULL)return NULL;//向上寻找前驱while(p){if(p->parent->right == p)break;p=p->parent;}return p->parent;}}//查找某个结点的后继PNode searchSuccessor(PNode p){//空树if(p==NULL)return p;//有右子树、右子树中最小的那个if(p->right)return searchMin(p->right);//无右子树,查找某个结点的左子树遍历完了 else{if(p->parent == NULL)return NULL;//向上寻找后继while(p){if(p->parent->left == p)break;p=p->parent;}return p->parent;}}//根据关键字删除某个结点,删除成功返回1,否则返回0//如果把根结点删掉,那么要改变根结点的地址,所以传二级指针int deleteNode(PNode* root,KeyType key){PNode q;//查找到要删除的结点PNode p=search(*root,key);KeyType temp; //暂存后继结点的值//没查到此关键字if(!p)return 0;//1.被删结点是叶子结点,直接删除if(p->left == NULL && p->right == NULL){//只有一个元素,删完之后变成一颗空树if(p->parent == NULL){free(p);(*root)=NULL;}else{//删除的结点是父节点的左孩子if(p->parent->left == p)p->parent->left=NULL;else //删除的结点是父节点的右孩子 p->parent->right=NULL;free(p);}}//2.被删结点只有左子树else if(p->left && !(p->right)){p->left->parent=p->parent;//如果删除是父结点,要改变父节点指针 if(p->parent == NULL)*root=p->left;//删除的结点是父节点的左孩子else if(p->parent->left == p)p->parent->left=p->left;else //删除的结点是父节点的右孩子p->parent->right=p->left;free(p);}//3.被删结点只有右孩子else if(p->right && !(p->left)){p->right->parent=p->parent;//如果删除是父结点,要改变父节点指针if(p->parent == NULL)*root=p->right;//删除的结点是父节点的左孩子else if(p->parent->left == p)p->parent->left=p->right;else //删除的结点是父节点的右孩子p->parent->right=p->right;free(p);}//4.被删除的结点既有左孩子,又有右孩子//该结点的后继结点肯定无左子树(参考上面查找后继结点函数) //删掉后继结点,后继结点的值代替该结点else{//找到要删除结点的后继q=searchSuccessor(p);temp=q->key;//删除后继结点deleteNode(root,q->key);p->key=temp;}return 1;}//创建一棵二叉查找树void create(PNode* root,KeyType *keyArray,int length) {int i;//逐个结点插入二叉树中for(i=0;i<length;i++)inseart(root,keyArray[i]);}int main(void){int i;PNode root=NULL;KeyType nodeArray[11]={15,6,18,3,7,17,20,2,4,13,9}; create(&root,nodeArray,11);for(i=0;i<2;i++)deleteNode(&root,nodeArray[i]);printf("%d\n",searchPredecessor(root)->key); printf("%d\n",searchSuccessor(root)->key); printf("%d\n",searchMin(root)->key);printf("%d\n",searchMax(root)->key);printf("%d\n",search(root,13)->key);return 0;}图1:二叉树排序实验结果。
实验报告:二叉树
实验报告:二叉树第一篇:实验报告:二叉树实验报告二叉树一实验目的1、进一步掌握指针变量,动态变量的含义;2、掌握二叉树的结构特性以及各种存储结构的特点及适用范围。
3、掌握用指针类型描述、访问和处理二叉树的运算。
4、熟悉各种存储结构的特征以及如何应用树结构解决具体问题。
二实验原理树形结构是一种应用十分广泛和重要的非线性数据结构,是一种以分支关系定义的层次结构。
在这种结构中,每个数据元素至多只有一个前驱,但可以有多个后继;数据元素之间的关系是一对多的层次关系。
树形结构主要用于描述客观世界中具有层次结构的数据关系,它在客观世界中大量存在。
遍历二叉树的实质是将非线性结构转为线性结构。
三使用仪器,材料计算机 2 Wndows xp 3 VC6.0四实验步骤【问题描述】建立一个二叉树,请分别按前序,中序和后序遍历该二叉树。
【基本要求】从键盘接受输入(按前序顺序),以二叉链表作为存储结构,建立二叉树(以前序来建立),并采用递归算法对其进行前序,中序和后序遍历,将结果输出。
【实现提示】按前序次序输入二叉树中结点的值(一个整数),0表示空树,叶子结点的特征是其左右孩子指针为空。
五实验过程原始记录基本数据结构描述; 2 函数间的调用关系;用类C语言描述各个子函数的算法;附录:源程序。
六试验结果分析将实验结果分析、实验中遇到的问题和解决问题的方法以及关于本实验项目的心得体会,写在实验报告上。
第二篇:数据结构-二叉树的遍历实验报告实验报告课程名:数据结构(C语言版)实验名:二叉树的遍历姓名:班级:学号:时间:2014.11.03一实验目的与要求1.掌握二叉树的存储方法2.掌握二叉树的三种遍历方法3.实现二叉树的三种遍历方法中的一种二实验内容• 接受用户输入一株二叉树• 输出这株二叉树的前根, 中根, 后根遍历中任意一种的顺序三实验结果与分析//*********************************************************** //头文件#include #include //*********************************************************** //宏定义#define OK 1 #define ERROR 0 #define OVERFLOW 0//*********************************************************** typedef struct BiTNode { //二叉树二叉链表存储结构char data;struct BiTNode *lChild,*rChild;}BiTNode,*BiTree;//******************************** *************************** int CreateBiTree(BiTree &T){ //按先序次序输入二叉中树结点的值,空格表示空树//构造二叉链表表示的二叉树T char ch;fflush(stdin);scanf(“%c”,&ch);if(ch==' ')T=NULL;else{ if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))return(OVERFLOW);T->data=ch;Creat eBiTree(T->lChild);CreateBiTree(T->rChild);} return(OK);} //********************************************************* void PreOrderTraverse(BiTree T){ //采用二叉链表存储结构,先序遍历二叉树的递归算法if(T){ printf(“%c”,T->data);PreOrderTraverse(T->lChild);PreOrd erTraverse(T->rChild);} } /***********************************************************/ void InOrderTraverse(BiTree T){ //采用二叉链表存储结构,中序遍历二叉树的递归算法if(T){ InOrderTraverse(T->lChild);printf(“%c”,T->data);InOrderT raverse(T->rChild);} }//*********************************************************** void PostOrderTraverse(BiTree T){ //采用二叉链表存储结构,后序遍历二叉树的递归算法if(T){ PostOrderTraverse(T->lChild);PostOrderTraverse(T->rChild) ;printf(“%c”,T->data);} }//*********************************************************** void main(){ //主函数分别实现建立并输出先、中、后序遍历二叉树printf(“please input your tree follow the PreOrder:n”);BiTNode *Tree;CreateBiTree(Tree);printf(“n先序遍历二叉树:”);PreOrderTraverse(Tree);printf(“n中序遍历二叉树:”);InOrderTraverse(Tree);printf(“n后序遍历二叉树:”);PostOrderTraverse(Tree);}图1:二叉树的遍历运行结果第三篇:数据结构二叉树操作验证实验报告班级:计算机11-2 学号:40 姓名:朱报龙成绩:_________实验七二叉树操作验证一、实验目的⑴ 掌握二叉树的逻辑结构;⑵ 掌握二叉树的二叉链表存储结构;⑶ 掌握基于二叉链表存储的二叉树的遍历操作的实现。
数据结构实验报告 二叉树
数据结构实验报告二叉树数据结构实验报告:二叉树引言:数据结构是计算机科学中的重要基础,它为我们提供了存储和组织数据的方式。
二叉树作为一种常见的数据结构,广泛应用于各个领域。
本次实验旨在通过实践,深入理解二叉树的概念、性质和操作。
一、二叉树的定义与性质1.1 定义二叉树是一种特殊的树结构,每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉树可以为空树,也可以是由根节点和左右子树组成的非空树。
1.2 基本性质(1)每个节点最多有两个子节点;(2)左子树和右子树是有顺序的,不能颠倒;(3)二叉树的子树仍然是二叉树。
二、二叉树的遍历2.1 前序遍历前序遍历是指首先访问根节点,然后按照先左后右的顺序遍历左右子树。
在实际应用中,前序遍历常用于复制一颗二叉树或创建二叉树的副本。
2.2 中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。
中序遍历的结果是一个有序序列,因此在二叉搜索树中特别有用。
2.3 后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。
后序遍历常用于计算二叉树的表达式或释放二叉树的内存。
三、二叉树的实现与应用3.1 二叉树的存储结构二叉树的存储可以使用链式存储或顺序存储。
链式存储使用节点指针连接各个节点,而顺序存储则使用数组来表示二叉树。
3.2 二叉树的应用(1)二叉搜索树:二叉搜索树是一种特殊的二叉树,它的左子树上的节点都小于根节点,右子树上的节点都大于根节点。
二叉搜索树常用于实现查找、插入和删除等操作。
(2)堆:堆是一种特殊的二叉树,它满足堆序性质。
堆常用于实现优先队列,如操作系统中的进程调度。
(3)哈夫曼树:哈夫曼树是一种带权路径最短的二叉树,常用于数据压缩和编码。
四、实验结果与总结通过本次实验,我成功实现了二叉树的基本操作,包括创建二叉树、遍历二叉树和查找节点等。
在实践中,我进一步理解了二叉树的定义、性质和应用。
二叉树作为一种重要的数据结构,在计算机科学中有着广泛的应用,对于提高算法效率和解决实际问题具有重要意义。
二叉排序树的实验报告
二叉排序树的实验报告二叉排序树的实验报告引言:二叉排序树(Binary Search Tree,简称BST)是一种常用的数据结构,它将数据按照一定的规则组织起来,便于快速的查找、插入和删除操作。
本次实验旨在深入了解二叉排序树的原理和实现,并通过实验验证其性能和效果。
一、实验背景二叉排序树是一种二叉树,其中每个节点的值大于其左子树的所有节点的值,小于其右子树的所有节点的值。
这种特性使得在二叉排序树中进行查找操作时,可以通过比较节点的值来确定查找的方向,从而提高查找效率。
二、实验目的1. 理解二叉排序树的基本原理和性质;2. 掌握二叉排序树的构建、插入和删除操作;3. 验证二叉排序树在查找、插入和删除等操作中的性能和效果。
三、实验过程1. 构建二叉排序树首先,我们需要构建一个空的二叉排序树。
在构建过程中,我们可以选择一个节点作为根节点,并将其他节点插入到树中。
插入节点时,根据节点的值与当前节点的值进行比较,如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。
重复这个过程,直到所有节点都被插入到树中。
2. 插入节点在已有的二叉排序树中插入新的节点时,我们需要遵循一定的规则。
首先,从根节点开始,将新节点的值与当前节点的值进行比较。
如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。
如果新节点的值与当前节点的值相等,则不进行插入操作。
3. 删除节点在二叉排序树中删除节点时,我们需要考虑不同的情况。
如果要删除的节点是叶子节点,即没有左右子树,我们可以直接删除该节点。
如果要删除的节点只有一个子树,我们可以将子树连接到要删除节点的父节点上。
如果要删除的节点有两个子树,我们可以选择将其右子树中的最小节点或左子树中的最大节点替代该节点,并删除相应的替代节点。
四、实验结果通过对二叉排序树的构建、插入和删除操作的实验,我们得到了以下结果:1. 二叉排序树可以高效地进行查找操作。
数据结构实验报告二二叉树实验
实验报告课程名称:数据结构
第 1 页共4 页
五、实验总结(包括心得体会、问题回答及实验改进意见,可附页)
这次实验主要是建立二叉树,和二叉树的先序、中序、后续遍历算法。
通过这次实验,我巩固了二叉树这部分知识,从中体会理论知识的重要性。
在做实验之前,要充分的理解本次实验的理论依据,这样才能达到事半功倍的效果。
如果在没有真正理解实验原理之盲目的开始实验,只会浪费时间和精力。
例如进行二叉树的遍历的时候,要先理解各种遍历的特点。
先序遍历是先遍历根节点,再依次先序遍历左右子树。
中序遍历是先中序遍历左子树,再访问根节点,最后中序遍历右子树。
而后序遍历则是先依次后续遍历左右子树,再访问根节点。
掌握了这些,在实验中我们就可以融会贯通,举一反三。
其次要根据不光要懂得代码的原理,还要对题目有深刻的了解,要明白二叉树的画法,在纸上先进行自我演练,对照代码验证自己写的正确性。
第 3 页共4 页
第 4 页共4 页。
二叉排序树实验报告
深圳大学实验报告
课程名称:数据结构实验与课程设计
实验项目名称:二叉排序树实验
学院:计算机与软件学院
专业:
指导教师:
报告人:学号:班级: 3班
实验时间: 2012-11-28 实验报告提交时间: 2012-12-5
教务部制
int main(int argc,char *argv[])
{
int t[32];
int i,j,Key;
int TestNum,SampleNum;
// freopen("cin.txt","r",stdin);
// freopen("cout.txt","w",stdout);
BiSortTree *BST=new BiSortTree;
cin>>TestNum;
for(i=0;i<TestNum;i++){
cin>>SampleNum;
for(j=0;j<SampleNum;j++) cin>>t[j];
BST->CreateBST(t,SampleNum);
cin>>Key;
BST->SearchBST(Key);
cout<<BST->BisSuccess<<" "<<BST->BisPos <<" "<<BST->BisCount<<endl;
}
return 0;
}
运行截图:
2、教师批改学生实验报告时间应在学生提交实验报告时间后10日内。
数据结构二叉树的实验报告
数据结构二叉树的实验报告数据结构二叉树的实验报告一、引言数据结构是计算机科学中非常重要的一个领域,它研究如何组织和存储数据以便高效地访问和操作。
二叉树是数据结构中常见且重要的一种,它具有良好的灵活性和高效性,被广泛应用于各种领域。
本实验旨在通过实际操作和观察,深入了解二叉树的特性和应用。
二、实验目的1. 理解二叉树的基本概念和特性;2. 掌握二叉树的创建、遍历和查找等基本操作;3. 通过实验验证二叉树的性能和效果。
三、实验过程1. 二叉树的创建在实验中,我们首先需要创建一个二叉树。
通过输入一系列数据,我们可以按照特定的规则构建一棵二叉树。
例如,可以按照从小到大或从大到小的顺序将数据插入到二叉树中,以保证树的有序性。
2. 二叉树的遍历二叉树的遍历是指按照一定的次序访问二叉树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历是先访问根节点,然后再依次遍历左子树和右子树;中序遍历是先遍历左子树,然后访问根节点,最后再遍历右子树;后序遍历是先遍历左子树,然后遍历右子树,最后访问根节点。
3. 二叉树的查找二叉树的查找是指在二叉树中寻找指定的节点。
常见的查找方式有深度优先搜索和广度优先搜索。
深度优先搜索是从根节点开始,沿着左子树一直向下搜索,直到找到目标节点或者到达叶子节点;广度优先搜索是从根节点开始,逐层遍历二叉树,直到找到目标节点或者遍历完所有节点。
四、实验结果通过实验,我们可以观察到二叉树的特性和性能。
在创建二叉树时,如果按照有序的方式插入数据,可以得到一棵平衡二叉树,其查找效率较高。
而如果按照无序的方式插入数据,可能得到一棵不平衡的二叉树,其查找效率较低。
在遍历二叉树时,不同的遍历方式会得到不同的结果。
前序遍历可以用于复制一棵二叉树,中序遍历可以用于对二叉树进行排序,后序遍历可以用于释放二叉树的内存。
在查找二叉树时,深度优先搜索和广度优先搜索各有优劣。
深度优先搜索在空间复杂度上较低,但可能会陷入死循环;广度优先搜索在时间复杂度上较低,但需要较大的空间开销。
数据结构二叉树实验报告
数据结构二叉树实验报告二叉树是一种常用的数据结构,它在计算机科学中有着广泛的应用。
本文将介绍二叉树的定义、基本操作以及一些常见的应用场景。
一、二叉树的定义和基本操作二叉树是一种特殊的树形结构,它的每个节点最多有两个子节点。
一个节点的左子节点称为左子树,右子节点称为右子树。
二叉树的示意图如下:```A/ \B C/ \D E```在二叉树中,每个节点可以有零个、一个或两个子节点。
如果一个节点没有子节点,我们称之为叶子节点。
在上面的示例中,节点 D 和 E 是叶子节点。
二叉树的基本操作包括插入节点、删除节点、查找节点和遍历节点。
插入节点操作可以将一个新节点插入到二叉树中的合适位置。
删除节点操作可以将一个指定的节点从二叉树中删除。
查找节点操作可以在二叉树中查找指定的节点。
遍历节点操作可以按照一定的顺序遍历二叉树中的所有节点。
二、二叉树的应用场景二叉树在计算机科学中有着广泛的应用。
下面将介绍一些常见的应用场景。
1. 二叉搜索树二叉搜索树是一种特殊的二叉树,它的每个节点的值都大于其左子树中的节点的值,小于其右子树中的节点的值。
二叉搜索树可以用来实现快速的查找、插入和删除操作。
它在数据库索引、字典等场景中有着重要的应用。
2. 堆堆是一种特殊的二叉树,它的每个节点的值都大于或小于其子节点的值。
堆可以用来实现优先队列,它在任务调度、操作系统中的内存管理等场景中有着重要的应用。
3. 表达式树表达式树是一种用来表示数学表达式的二叉树。
在表达式树中,每个节点可以是操作符或操作数。
表达式树可以用来实现数学表达式的计算,它在编译器、计算器等场景中有着重要的应用。
4. 平衡二叉树平衡二叉树是一种特殊的二叉树,它的左子树和右子树的高度差不超过1。
平衡二叉树可以用来实现高效的查找、插入和删除操作。
它在数据库索引、自平衡搜索树等场景中有着重要的应用。
三、总结二叉树是一种常用的数据结构,它在计算机科学中有着广泛的应用。
本文介绍了二叉树的定义、基本操作以及一些常见的应用场景。
数据结构二叉树实验报告总结
数据结构二叉树实验报告总结一、实验目的本次实验的主要目的是通过对二叉树的学习和实践,掌握二叉树的基本概念、性质和遍历方式,加深对数据结构中树形结构的理解。
二、实验内容1. 二叉树的基本概念和性质在本次实验中,我们首先学习了二叉树的基本概念和性质。
其中,二叉树是由节点组成的有限集合,并且每个节点最多有两个子节点。
同时,我们还学习了二叉树的高度、深度、层数等概念。
2. 二叉树的遍历方式在了解了二叉树的基本概念和性质之后,我们开始学习如何遍历一个二叉树。
在本次实验中,我们主要学习了三种遍历方式:前序遍历、中序遍历和后序遍历。
其中,前序遍历指先访问节点自身再访问左右子节点;中序遍历指先访问左子节点再访问自身和右子节点;后序遍历指先访问左右子节点再访问自身。
3. 二叉搜索树除了以上内容之外,在本次实验中我们还学习了一种特殊的二叉树——二叉搜索树。
二叉搜索树是一种特殊的二叉树,它的每个节点都满足左子节点小于该节点,右子节点大于该节点的性质。
由于这个性质,二叉搜索树可以被用来进行快速查找、排序等操作。
三、实验过程1. 实现二叉树的遍历方式为了更好地理解和掌握二叉树的遍历方式,我们首先在编程环境中实现了前序遍历、中序遍历和后序遍历。
在代码编写过程中,我们需要考虑如何递归地访问每个节点,并且需要注意访问顺序。
2. 实现二叉搜索树为了更好地理解和掌握二叉搜索树的特性和操作,我们在编程环境中实现了一个简单的二叉搜索树。
在代码编写过程中,我们需要考虑如何插入新节点、删除指定节点以及查找目标节点等操作。
3. 实验结果分析通过对代码运行结果进行分析,我们可以清晰地看到每个遍历方式所得到的结果以及对应的顺序。
同时,在对二叉搜索树进行操作时,我们也可以看到不同操作所产生的不同结果。
四、实验总结通过本次实验,我们进一步加深了对二叉树的理解和掌握,学习了二叉树的遍历方式以及二叉搜索树的特性和操作。
同时,在编程实践中,我们也进一步熟悉了代码编写和调试的过程。
数据结构二叉排序树实验报告
*bst=s;
}
else if(key<(*bst)->key)
InsertBST(&((*bst)->lchild),key);//将s插入左子串
else if(key>(*bst)->key)
InsertBST(&((*bst)->rchild),key);//将s插入右子串
InsertBST(BSTree *bst,int key)
inorder(BSTree bt)
3、完整的程序:
#include"stdio.h"
#include"malloc.h"
typedef struct node
{
int key;//关键字的值
struct node *lchild,*rchild;//左右指针
}BSTNode,*BSTree;
元素类型为整形和指针形。
2、每个模块的分析:
(1)主程序模块:
main()
{
BSTree bt;
printf("please insert the numbers( 以0作为结束标志):\n");
CreateBST(&bt); /*构造排序二叉树*/
printf("\n中序遍历结果是:");
s->rchild=NULL;
*bst=s;
}
else if(key<(*bst)->key)
InsertBST(&((*bst)->lchild),key);//将s插入左子串
else if(key>(*bst)->key)
数据结构二叉树实验报告
(1)输出二叉树b;
(2)输出H节点的左、右孩子节点值;
(3)输出二叉树b的深度;
(4)输出二叉树b的宽度;
(5)输出二叉树b的节点个数;
(6)输出二叉树b的叶子节点个数。
实验7.2设计一个程序exp7-2.cpp,实现二叉树的先序遍历、中序遍历和后序遍历和非递归算法,以及层次变量里的算法。并对图7-123所示的二叉树b给出求解结果。
(6)重点掌握二叉树ຫໍສະໝຸດ 基本运算和各种遍历算法的实现。(7)掌握线索二叉树的概念和相关算法的实现。
(8)掌握哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码的产生方法。
(9)掌握并查集的相关概念和算法。
(10)灵活运用二叉树这种数据结构解决一些综合应用问题。
二、实验容
注:二叉树b为如图7-123所示的一棵二叉树
一、实验目的和要求
(1)掌握树的相关概念,包括树、节点的度、树的度、分支节点、叶子节点、孩子节点、双亲节点、树的深度、森林等定义。
(2)掌握树的表示,包括树形表示法、文氏图表示法、凹入表示法和括号表示法等。
(3)掌握二叉树的概念,包括二叉树、满二叉树和完全二叉树的定义。
(4)掌握二叉树的性质。
(5)重点掌握二叉树的存储结构,包括二叉树顺序存储结构和链式存储结构。
实验7.3对如图7-123所示的二叉树,设计一个程序exp7-3.cpp,完成如下功能:
(1)输出所有的叶子节点;
(2)输出所有从叶子节点到根节点的路径;
(3)输出(2)中的第一条最长的路径。
三、实验过程描述
实现二叉树的各种的基础程序algo7-1.cpp如下:
数据结构实验报告二叉树
数据结构实验报告二叉树二叉树是一种重要的数据结构,广泛应用于计算机科学和算法设计中。
在本次实验中,我们通过实际编程实践,深入理解了二叉树的基本概念、性质和操作。
一、二叉树的定义和基本性质二叉树是一种特殊的树结构,每个节点最多有两个子节点。
它具有以下基本性质:1. 根节点:二叉树的顶部节点称为根节点,它没有父节点。
2. 子节点:每个节点最多有两个子节点,分别称为左子节点和右子节点。
3. 叶节点:没有子节点的节点称为叶节点。
4. 深度:从根节点到某个节点的路径长度称为该节点的深度。
5. 高度:从某个节点到其叶节点的最长路径长度称为该节点的高度。
6. 层次遍历:按照从上到下、从左到右的顺序遍历二叉树的节点。
二、二叉树的实现在本次实验中,我们使用C++语言实现了二叉树的基本操作,包括创建二叉树、插入节点、删除节点、查找节点等。
通过这些操作,我们可以方便地对二叉树进行增删改查。
三、二叉树的遍历二叉树的遍历是指按照某种顺序访问二叉树的所有节点。
常用的遍历方式有三种:前序遍历、中序遍历和后序遍历。
1. 前序遍历:先访问根节点,然后依次递归遍历左子树和右子树。
2. 中序遍历:先递归遍历左子树,然后访问根节点,最后递归遍历右子树。
3. 后序遍历:先递归遍历左子树,然后递归遍历右子树,最后访问根节点。
四、二叉树的应用二叉树在计算机科学和算法设计中有广泛的应用。
以下是一些常见的应用场景:1. 二叉搜索树:二叉搜索树是一种特殊的二叉树,它的左子树的值都小于根节点的值,右子树的值都大于根节点的值。
它可以高效地支持插入、删除和查找操作,常用于有序数据的存储和检索。
2. 堆:堆是一种特殊的二叉树,它的每个节点的值都大于(或小于)其子节点的值。
堆常用于实现优先队列等数据结构。
3. 表达式树:表达式树是一种用二叉树表示数学表达式的方法。
通过对表达式树的遍历,可以实现对数学表达式的计算。
4. 平衡树:平衡树是一种特殊的二叉树,它的左右子树的高度差不超过1。
数据结构_二叉排序树实验报告
一、实验目的1、巩固和加深对数据结构课程基本知识的理解,综合数据结构课程里学的理论知识,完成对排序二叉树程序的设计。
2、理解和掌握二叉树的各种基本数据结构的定义、存储结构和相应的算法,并能够用c语言实现。
3、理解排序二叉树的建立过程。
二、实验内容采用llink-rlink方式存储二叉排序树,编写能够通过键盘输入建立二叉排序树,并在建立完立即在屏幕显示中序遍历结果的程序。
三、实验环境1、硬件配置:Pentium(R) Dual-Core9 CUP E6500 @2.93GHz,1.96的内存2、软件环境:Microsoft Windows XP Professional Service Pack 3,Microsoft Visual C++ 6.0四、需求分析1、输入的形式和输入值的范围:根据题目要求与提示输入一些数字,且数与数之间用空格隔开并用0作为结束符。
2、输出的形式:建立好的排序二叉树的中序遍历结果。
3、程序所能达到的功能:能够通过键盘输入建立二叉排序树,并在建立完立即在屏幕显示中序遍历结果的程序4、测试数据:输入45 24 53 12 28 90并用空格将数隔开,以0作为结束符,如:输入45 24 53 12 28 90输出的中序遍历结果为:12 24 28 45 53 90五、概要设计为了实现上述操作,应以结构体为存储结构。
实现如下:struct node{int key;//关键字的值struct node *lchild,*rchild;//左右指针}BSTNode,*BSTree;1、基本操作:(1)struct node{int key;//关键字的值struct node *lchild,*rchild;//左右指针}BSTNode,*BSTree;。
(2)void CreateBST(BSTree *bst) 创建二叉排序树(3)void inorder(BSTree bt) 递归法中序遍历二叉排序树(4)void InsertBST(BSTree *bst,int key) 二叉排序树的插入结点2、本程序包含二个模块:(1)主程序模块;(2)创建二叉排序树、二叉排序树的插入结点、递归法中序遍历二叉排序树(3)模块调用图:主程序模块创建二叉排序树二叉排序树的插入结点递归法中序遍历二叉排序树3、流程图流程图如下:开始定义BSTree 变量 bt;printf("please insert the numbers( 以0作为结束标志):\n");调用CreateBST(BSTree *bst)函数定义int 型变量key;key!=0调用InsertBST(BSTree *bst,int key)函数*bst=NULL scanf("%d",&key)NYBSTree s;*bst==NULLkey<(*bst)->keys=(BSTree)malloc(sizeof(BSTNode));key>(*bst)->keyNYYNInsertBST(&((*bst)->lchild),key)InsertBST(&((*bst)->rchild),key)YNscanf("%d",&key);printf("\n 中序遍历结果是:");调用 inorder(BSTree bt)函数bt!=NULLinorder(bt->lchild)YNprintf("%3d",bt->key)inorder(bt->lchild)printf("\n")getchar()结束六、详细设计1、存储类型,元素类型,结点类型:struct node{int key;//关键字的值struct node *lchild,*rchild;//左右指针}BSTNode,*BSTree;元素类型为整形和指针形。
数据结构实验报告—二叉树
数据结构实验报告—二叉树目录1. 引言1.1 背景1.2 目的2. 前期准备2.1 问题定义2.2 数据准备3. 算法设计3.1 插入节点3.2 删除节点3.3 查找节点3.4 遍历二叉树4. 实验过程4.1 实验环境4.2 实验步骤5. 实验结果与分析5.1 插入节点的结果 5.2 删除节点的结果 5.3 查找节点的结果5.4 遍历二叉树的结果6. 总结与讨论6.1 实验总结6.2 实验改进方向7. 结论8. 参考文献1. 引言1.1 背景介绍二叉树的概念和应用领域,以及在数据结构中的重要性。
1.2 目的明确本实验的目标,即设计一个能够实现插入、删除、查找和遍历二叉树的算法,并对其进行实验验证。
2. 前期准备2.1 问题定义对二叉树的基本操作进行定义,包括插入节点、删除节点、查找节点和遍历二叉树。
2.2 数据准备准备一组用于测试的数据集,包括插入节点、删除节点和查找节点时所需的数据。
3. 算法设计3.1 插入节点详细描述如何设计实现插入节点的算法,并分析算法的时间复杂度和空间复杂度。
3.2 删除节点详细描述如何设计实现删除节点的算法,并分析算法的时间复杂度和空间复杂度。
3.3 查找节点详细描述如何设计实现查找节点的算法,并分析算法的时间复杂度和空间复杂度。
3.4 遍历二叉树详细描述如何设计实现遍历二叉树的算法,并分析算法的时间复杂度和空间复杂度。
4. 实验过程4.1 实验环境描述实验所用的编程语言和相关工具的环境配置。
4.2 实验步骤详细描述实验的具体步骤,包括数据准备、算法实现、代码编写、实验运行和结果分析等。
5. 实验结果与分析5.1 插入节点的结果展示插入节点的实验结果,并对结果进行详细分析和讨论。
5.2 删除节点的结果展示删除节点的实验结果,并对结果进行详细分析和讨论。
5.3 查找节点的结果展示查找节点的实验结果,并对结果进行详细分析和讨论。
5.4 遍历二叉树的结果展示遍历二叉树的实验结果,并对结果进行详细分析和讨论。
二叉树实验报告总结(共10篇)
二叉树实验报告总结(共10篇)二叉树实验报告实验报告课程名称算法与数据结构专业学号姓名实验日期算法与数据结构实验报告一、实验目的1.了解二叉树的结构特点及有关概念,掌握二叉树建立的基本算法2.了解二叉树遍历的概念,掌握遍历二叉的算法3.进一步掌握树的结构及非线性特点,递归特点和动态性。
二、实验内容二叉树的实现和运算三、实验要求1.用C++/C完成算法设计和程序设计并上机调试通过。
2.撰写实验报告,提供实验结果和数据。
3.分析算法,并简要给出算法设计小结和心得。
四、算法步骤用户以三元组形式输入二叉树的结点元素及其位置关系,建立二叉树,并打印输出该二叉树。
用户输入选择结点,程序调用BiTNode* Find Node(char tag, BiTNode* node)函数,返回子树的根结点,然后调用BiTreeDepth(BiTree T)函数,求出子树的深度,并输出该值。
3.用户可以选择是否继续执行程序,若继续,则输入1,否则输入0,结束程序。
五、主程序代码:int main(void){BiTree T;TElemType e1;char node; // node为用户选择输入的结点//int b,choose; // b为以选定结点为子树的深度,choose为实现多次选择输入的标志//BiTNode* a; // a为选定结点为子树的根结点//choose=1; // 多次选择的标志,当choose为1时运行程序,为0时结束程序// InitBiTree(T);printf(构造空二叉树后,树空否?%d(1:是0:否), 树的深度=%d\n,BiTreeEmpty(T),BiTreeDepth(T));e1 = Root(T);if(e1 != Nil)#ifdef CHARprintf(二叉树的根为: %c\n,e1);#endif#ifdef INTprintf(二叉树的根为: %d\n,e1);#endifelseprintf(树空,无根\n); //三元组构建二叉树striile(x!=end){AddNode(T, x[0], x[1], x[2]);GetUserWord(x);} //输出树PrintTreeLevel( T );//以三元组形式输入任意二叉树(以大写字母表示结点),求以任意一选定结点为子树的深度。
二叉排序树实验报告
二叉排序树实验报告二叉排序树实验报告一、引言二叉排序树,也被称为二叉搜索树,是一种常见的数据结构,它具有快速的查找和插入操作的特点。
在本次实验中,我们将探索二叉排序树的原理和实现,并通过实际操作来验证其性能和效果。
二、实验目的本次实验的目的是通过实际操作,深入理解二叉排序树的原理和实现,并通过对比不同操作的时间复杂度,评估其性能和效果。
三、实验过程1. 实验环境的搭建在开始实验之前,我们需要搭建一个合适的实验环境。
我们可以选择使用C++或者其他编程语言来实现二叉排序树。
在本次实验中,我们选择使用C++来实现。
2. 二叉排序树的实现首先,我们需要定义一个二叉排序树的数据结构。
这个数据结构包含一个根节点,每个节点包含一个值和两个指针,分别指向左子树和右子树。
通过递归的方式,我们可以实现二叉排序树的插入、删除和查找操作。
3. 实验数据的准备为了验证二叉排序树的性能和效果,我们需要准备一组实验数据。
这组数据可以是随机生成的整数,也可以是具有特定规律的数据。
我们可以选择不同规模的数据集来进行实验,以评估二叉排序树在不同情况下的表现。
4. 实验操作的执行通过实验数据的准备,我们可以开始执行实验操作。
首先,我们将数据依次插入到二叉排序树中,并记录下插入操作的时间。
然后,我们可以执行查找操作,查找树中是否包含某个特定的值,并记录下查找操作的时间。
最后,我们可以执行删除操作,删除树中的某个节点,并记录下删除操作的时间。
5. 实验结果的分析通过实验操作的执行,我们可以得到一组实验结果。
我们可以通过对比不同操作的时间复杂度,来评估二叉排序树的性能和效果。
同时,我们还可以观察实验结果中树的结构,以验证二叉排序树的正确性。
四、实验结果与讨论通过实验操作的执行,我们得到了一组实验结果。
我们可以观察到,随着数据规模的增加,插入、查找和删除操作的时间逐渐增加。
这是因为二叉排序树的操作时间复杂度与树的高度相关,当树的高度增加时,操作的时间复杂度也会增加。
数据结构二叉树实验报告(附代码)
一、【实验构思(Conceive)】(10%)(本部分应包括:描述实验实现的基本思路,包括所用到的离散数学、工程数学、程序设计、算法等相关知识)首先构造二叉树的存储结构,用data存储当前节点的值,分别用*lchild,*rchild 表示该节点的左右孩子。
然后应用BiTree Create函数,根据用户的输入构造二叉树,当输入#时表示没有孩子。
采用递归的思想构造Preorder,Inorder,Postorder函数,分别实现二叉树的先序,中序,和后序的遍历。
然后编写了Sumleaf,Depth函数,来求叶子节点的数目和二叉树的深度。
二、【实验设计(Design)】(20%)(本部分应包括:抽象数据类型的功能规格说明、主程序模块、各子程序模块的伪码说明,主程序模块与各子程序模块间的调用关系)二叉树的存储结构:typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;子程序模块:BiTree Create(BiTree T){char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("Error!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild);}return T;}void Preorder(BiTree T){if(T){printf("%c",T->data);Preorder(T->lchild);Preorder(T->rchild);}}int Sumleaf(BiTree T){int sum=0,m,n;if(T){if((!T->lchild)&&(!T->rchild)) sum++;m=Sumleaf(T->lchild);sum+=m;n=Sumleaf(T->rchild);sum+=n;}return sum;}void Inorder(BiTree T) {if(T){Inorder(T->lchild); printf("%c",T->data); Inorder(T->rchild); }}void Postorder(BiTree T) {if(T){Postorder(T->lchild); Postorder(T->rchild); printf("%c",T->data); }}int Depth(BiTree T){int dep=0,depl,depr;if(!T)dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}主程序模块:int main(){BiTree T = 0;int sum,dep;printf("请输入你需要建立的二叉树\n");printf("例如输入序列ABC##DE#G##F###(其中的#表示空)\n并且输入过程中不要加回车\n输入完之后可以按回车退出\n");T=Create(T);printf("先序遍历的结果是:\n");Preorder(T);printf("\n");printf("中序遍历的结果是:\n");Inorder(T);printf("\n");printf("后序遍历的结果是:\n");Postorder(T);printf("\n");printf("统计的叶子数:\n");sum=Sumleaf(T);printf("%d",sum);printf("\n统计树的深度:\n");dep=Depth(T);printf("\n%d\n",dep);}三、【实现描述(Implement)】(30%)(本部分应包括:抽象数据类型具体实现的函数原型说明、关键操作实现的伪码算法、函数设计、函数间的调用关系,关键的程序流程图等,给出关键算法的时间复杂度分析。
数据结构实验-二叉排序树应用实验报告
实验报告实验课程:数据结构实验项目:实验四二叉排序树应用专业:计算机科学与技术班级:姓名:学号:指导教师:目录一、问题定义及需求分析(1)问题描述(2)实验任务(3)需求分析二、概要设计:(1)抽象数据类型定义(2)主程序流程(3) 模块关系三、详细设计(1)数据类型及存储结构(2)模块设计四、调试分析(1)调试分析(2)算法时空分析(3)经验体会五、使用说明(1)程序使用说明六、测试结果(1)运行测试结果截图七、附录(1)源代码一、问题定义及需求分析(1)实验目的二叉排序树应用问题描述互联网域名系统是一个典型的树形层次结构。
从根节点往下的第一层是顶层域,如cn、com等,最底层(第四层)是叶子结点,如www等。
因此,域名搜索可以构造树的结构完成;(2)实验任务设计基于二叉排序树的搜索互联网域名的程序。
(3)需求分析:1)采用二叉树的二叉链表存储结构。
2)完成二叉排序树的创建、插入、删除、查询操作。
3)可以考虑两棵二叉排序树的合并。
二、概要设计:(1)抽象数据类型定义:程序中定义了二叉排序树的节点类型;由数据域和左右孩子指针构成;指针类型为该节点类型,指向该类型的节点形成二叉排序树;数据域是由字符数组构成,用于存储节点数据信息。
(2)主程序流程:输入域名拆分域名并完成二叉排序树的创建调用功能函数进入功能菜单选择执行不同的操作(查找、插入、删除) 操作完毕后可选择返回功能函数继续执行操作或者结束程序(3)模块间的调用关系:创建二叉排序树功能函数查找插入选择结束三、详细设计采用二叉链表存储结构的二叉排序树的定义如下:typedef struct BiTNode{ElemType data[30]; //定义数据域类型为字符数组struct BiTNode *lchild, *rchild; //定义左右孩子节点指针}BiTNode, *BiTree;模块1-查找树中是否有待插入节点算法如下:int SearchBST(BiTree T, char *key, BiTree f, BiTree *p){if (!T) /* 查找不成功*/{*p = f;return 0;}else if(strcmp(key,T->data)==0) /* 查找成功*/{*p = T;return 1;}else if (strcmp(key,T->data)<0)return SearchBST(T->lchild, key, T, p); /* 若该节点小于当前节点,则在左子树中继续查找*/elsereturn SearchBST(T->rchild, key, T, p); /* 否则在右子树中继续查找*/ }模块2-插入节点算法如下:int InsertBST(BiTree *T, char *key){BiTree p,s;if (!SearchBST(*T, key, NULL, &p)) /* 查找不成功*/{s = (BiTNode*)malloc(sizeof(BiTNode));strcpy(s->data, key);s->lchild = s->rchild = NULL;if (!p)*T = s; /* 插入s为新的根结点*/else if (strcmp(key,p->data)<0)p->lchild = s; /* 插入s为左孩子*/elsep->rchild = s; /* 插入s为右孩子*/return 1;}elsereturn 0; /* 树中已有关键字相同的结点,不再插入*/}模块3-删除节点算法如下:int Delete(BiTree *p){BiTree q,s;if((*p)->rchild==NULL) /* 右子树空则只需重接它的左子树(待删结点是叶子也走此分支) */{q=*p;*p=(*p)->lchild;free(q);}else if((*p)->lchild==NULL) /* 只需重接它的右子树*/{q=*p;*p=(*p)->rchild;free(q);}else /* 左右子树均不空*/{q=*p;s=(*p)->lchild;while(s->rchild) /* 转左,然后向右到尽头(找待删结点的前驱)*/{q=s;s=s->rchild;}strcpy((*p)->data,s->data); /* s指向被删结点的直接前驱(将被删结点前驱的值取代被删结点的值)*/if(q!=*p)q->rchild=s->lchild; /* 重接q的右子树*/elseq->lchild=s->lchild; /* 重接q的左子树*/free(s);}return 1;}模块4-查找待删除节点的位置算法如下:int DeleteBST(BiTree *T,char *key){if(!*T) /* 不存在关键字等于key的数据元素*/return 0;else{if (strcmp(key,(*T)->data)==0) /* 找到关键字等于key的数据元素*/return Delete(T);else if (strcmp(key,(*T)->data)<0)return DeleteBST(&(*T)->lchild,key);/* 若待删除节点大于当前节点,则递归访问其左子树*/elsereturn DeleteBST(&(*T)->rchild,key);/* 否则访问右子树*/}}模块5-功能函数包括查找、插入和删除算法如下:void Gongneng(BiTNode *A){// 执行操作需将此树的根节点传入到此函数里面int k;char a[30],c[30],d[30];printf("请选择你的操作:\n");printf("1-查找\n");printf("2-删除\n");printf("3-插入\n");printf("输入:");scanf("%d",&k);switch(k){//通过switch语句执行不同的操作case 1 :system("cls");printf("请输入你要查找的节点:");scanf("%s",c);Search(A, c); //调用查找函数break;case 2:system("cls");printf("请输入你要删除的节点:");scanf("%s",a);if(!DeleteBST(&A,a))printf("\n不存在此节点!\n");else{printf("\n删除节点成功!\n\n删除后树的中序遍历结果如下:\n");InOrder(A);}break;case 3:system("cls");printf("请输入要插入的节点:");scanf("%s",d);if(!InsertBST(&A,d))printf("插入失败!要插入的节点已存在!\n");else{printf("\n插入成功!\n\n插入后树的中序遍历结果如下:\n");InOrder(A);}break;default : printf("输入数值错误!\n");}}四、调试分析问题及解决方法:在编写功能函数时,在参数的传递上出现了问题;无法正确的将根节点传入到功能函数里,导致功能函数无法正常运行;解决方法为:void Gongneng(BiTNode *A);时空分析:由于采用二叉链表的存储结构,所以在插入和删除算法的时间复杂度较低;而对于较多的数据元素形成的树时,查找算法在时间复杂度上不算简便;而存储方面,二叉链表构成的二叉排序树存储较为方便且空间利用率高;经验体会:二叉链表存储结构的存储密度较高,使用起来较为方便;而且在处理数据方面,二叉链表存储结构的处理性比较好,尤其是对插入和删除算法;五、使用说明第一步:点击运行按钮;第二步: 输入待输入的域名个数k;第三步:依次输入k个域名;第四步:回车,程序跳转至功能界面,根据提示输入想要执行的功能选项序号;第五步:回车后,针对各功能项有提示药查找、插入或者删除的节点;第六步:执行功能后,选择结束运行还是继续操作;第七步:若选择继续操作,则程序进入功能界面,可继续选择执行的功能;第八步:循环执行第四到七步;第九步:可在第六步选择退出程序;六、测试结果七、附录源代码:#include<stdio.h>#include<stdlib.h>#include<string.h>#define ElemType chartypedef struct BiTNode{ElemType data[30]; //定义数据域类型为字符数组struct BiTNode *lchild, *rchild; //定义左右孩子节点指针}BiTNode, *BiTree;int SearchBST(BiTree T, char *key, BiTree f, BiTree *p){if (!T) // 树为空,查找不成功{*p = f;return 0;}else if(strcmp(key,T->data)==0) // 查找成功{*p = T; //p指向查找到的节点return 1;}else if (strcmp(key,T->data)<0)return SearchBST(T->lchild, key, T, p); // 在左子树中继续查找elsereturn SearchBST(T->rchild, key, T, p); // 在右子树中继续查找}int InsertBST(BiTree *T, char *key){BiTree p,s;if (!SearchBST(*T, key, NULL, &p)) // 查找不成功{s = (BiTNode*)malloc(sizeof(BiTNode));//s作为插入节点strcpy(s->data, key);s->lchild = s->rchild = NULL;if (!p)*T = s; // 插入s为新的根结点else if (strcmp(key,p->data)<0)p->lchild = s; // 插入s为左孩子elsep->rchild = s; // 插入s为右孩子return 1;}elsereturn 0; // 树中已有关键字相同的结点,不再插入}int Search(BiTNode *N,char *key){ // 查找树中是否存在要插入的节点BiTNode *M;M=N;while(M!=NULL&&strcmp(M->data,key)!=0){ // 查找终止条件为树为空或者查找的节点数据与待查找的数据相同if(strcmp(M->data,key)<0)M=M->rchild; // 继续查找左子树elseM=M->lchild; // 继续查找右子树}if(!M)printf("查找失败!\n");elseprintf("查找成功!\n");}/* 从二叉排序树中删除结点p,并重接它的左或右子树。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告课程名:数据结构(C语言版)实验名:二叉排序树:班级:学号:撰写时间:2014.12.18一实验目的与要求1.掌握二叉排序树上进行插入和删除的操作2.利用C 语言实现该操作二实验内容•对于一个线形表, 利用不断插入的方法, 建立起一株二叉排序树•从该二叉排序树中删除一个叶子节点, 一个只有一个子树的非叶子节,一个有两个子树的非叶子节点。
三实验结果与分析#include<stdio.h>#include<stdlib.h>//二叉查找树结点描述typedef int KeyType;typedef struct Node{KeyType key; //关键字struct Node * left; //左孩子指针struct Node * right; //右孩子指针struct Node * parent; //指向父节点指针}Node,*PNode;//往二叉查找树中插入结点//插入的话,可能要改变根结点的地址,所以传的是二级指针void inseart(PNode * root,KeyType key){//初始化插入结点PNode p=(PNode)malloc(sizeof(Node));p->key=key;p->left=p->right=p->parent=NULL;//空树时,直接作为根结点if((*root)==NULL){*root=p;return;}//插入到当前结点(*root)的左孩子if((*root)->left == NULL && (*root)->key > key){p->parent=(*root);(*root)->left=p;return;}//插入到当前结点(*root)的右孩子if((*root)->right == NULL && (*root)->key < key){p->parent=(*root);(*root)->right=p;return;}if((*root)->key > key)inseart(&(*root)->left,key);else if((*root)->key < key)inseart(&(*root)->right,key);elsereturn;}//查找元素,找到返回关键字的结点指针,没找到返回NULL PNode search(PNode root,KeyType key){if(root == NULL)return NULL;if(key > root->key) //查找右子树return search(root->right,key);else if(key < root->key) //查找左子树return search(root->left,key);elsereturn root;//查找最小关键字,空树时返回NULLPNode searchMin(PNode root){if(root == NULL)return NULL;if(root->left == NULL)return root;else //一直往左孩子找,直到没有左孩子的结点return searchMin(root->left);}//查找最大关键字,空树时返回NULLPNode searchMax(PNode root){if(root == NULL)return NULL;if(root->right == NULL)return root;else //一直往右孩子找,直到没有右孩子的结点return searchMax(root->right);//查找某个结点的前驱PNode searchPredecessor(PNode p){//空树if(p==NULL)return p;//有左子树、左子树中最大的那个if(p->left)return searchMax(p->left);//无左子树,查找某个结点的右子树遍历完了else{if(p->parent == NULL)return NULL;//向上寻找前驱while(p){if(p->parent->right == p)break;p=p->parent;}return p->parent;}}//查找某个结点的后继PNode searchSuccessor(PNode p){//空树if(p==NULL)return p;//有右子树、右子树中最小的那个if(p->right)return searchMin(p->right);//无右子树,查找某个结点的左子树遍历完了else{if(p->parent == NULL)return NULL;//向上寻找后继while(p){if(p->parent->left == p)break;p=p->parent;}return p->parent;}}//根据关键字删除某个结点,删除成功返回1,否则返回0//如果把根结点删掉,那么要改变根结点的地址,所以传二级指针int deleteNode(PNode* root,KeyType key){PNode q;//查找到要删除的结点PNode p=search(*root,key);KeyType temp; //暂存后继结点的值//没查到此关键字if(!p)return 0;//1.被删结点是叶子结点,直接删除if(p->left == NULL && p->right == NULL){//只有一个元素,删完之后变成一颗空树if(p->parent == NULL){free(p);(*root)=NULL;}else{//删除的结点是父节点的左孩子if(p->parent->left == p)p->parent->left=NULL;else //删除的结点是父节点的右孩子p->parent->right=NULL;free(p);}}//2.被删结点只有左子树else if(p->left && !(p->right)){p->left->parent=p->parent;//如果删除是父结点,要改变父节点指针if(p->parent == NULL)*root=p->left;//删除的结点是父节点的左孩子else if(p->parent->left == p)p->parent->left=p->left;else //删除的结点是父节点的右孩子p->parent->right=p->left;free(p);}//3.被删结点只有右孩子else if(p->right && !(p->left)){p->right->parent=p->parent;//如果删除是父结点,要改变父节点指针if(p->parent == NULL)*root=p->right;//删除的结点是父节点的左孩子else if(p->parent->left == p)p->parent->left=p->right;else //删除的结点是父节点的右孩子p->parent->right=p->right;free(p);}//4.被删除的结点既有左孩子,又有右孩子//该结点的后继结点肯定无左子树(参考上面查找后继结点函数) //删掉后继结点,后继结点的值代替该结点else{//找到要删除结点的后继q=searchSuccessor(p);temp=q->key;//删除后继结点deleteNode(root,q->key);p->key=temp;}return 1;}//创建一棵二叉查找树void create(PNode* root,KeyType *keyArray,int length) {int i;//逐个结点插入二叉树中for(i=0;i<length;i++)inseart(root,keyArray[i]);}int main(void){int i;PNode root=NULL;KeyType nodeArray[11]={15,6,18,3,7,17,20,2,4,13,9};create(&root,nodeArray,11);for(i=0;i<2;i++)deleteNode(&root,nodeArray[i]);printf("%d\n",searchPredecessor(root)->key);printf("%d\n",searchSuccessor(root)->key);printf("%d\n",searchMin(root)->key);printf("%d\n",searchMax(root)->key);printf("%d\n",search(root,13)->key);return 0;}图1:二叉树排序实验结果。