二叉排序树 折半查找 顺序查找 数据结构
- 格式:doc
- 大小:39.00 KB
- 文档页数:4
实验五查找的应用一、实验目的:1、掌握各种查找方法及适用场合,并能在解决实际问题时灵活应用。
2、增强上机编程调试能力。
二、问题描述1.分别利用顺序查找和折半查找方法完成查找。
有序表(3,4,5,7,24,30,42,54,63,72,87,95)输入示例:请输入查找元素:52输出示例:顺序查找:第一次比较元素95第二次比较元素87 ……..查找成功,i=**/查找失败折半查找:第一次比较元素30第二次比较元素63 …..2.利用序列(12,7,17,11,16,2,13,9,21,4)建立二叉排序树,并完成指定元素的查询。
输入输出示例同题1的要求。
三、数据结构设计(选用的数据逻辑结构和存储结构实现形式说明)(1)逻辑结构设计顺序查找和折半查找采用线性表的结构,二叉排序树的查找则是建立一棵二叉树,采用的非线性逻辑结构。
(2)存储结构设计采用顺序存储的结构,开辟一块空间用于存放元素。
(3)存储结构形式说明分别建立查找关键字,顺序表数据和二叉树数据的结构体进行存储数据四、算法设计(1)算法列表(说明各个函数的名称,作用,完成什么操作)序号 名称 函数表示符 操作说明1 顺序查找 Search_Seq 在顺序表中顺序查找关键字的数据元素2 折半查找 Search_Bin 在顺序表中折半查找关键字的数据元素3 初始化 Init 对顺序表进行初始化,并输入元素4 树初始化 CreateBST 创建一棵二叉排序树5 插入 InsertBST 将输入元素插入到二叉排序树中6 查找 SearchBST在根指针所指二叉排序树中递归查找关键字数据元素 (2)各函数间调用关系(画出函数之间调用关系)typedef struct { ElemType *R; int length;}SSTable;typedef struct BSTNode{Elem data; //结点数据域 BSTNode *lchild,*rchild; //左右孩子指针}BSTNode,*BSTree; typedef struct Elem{ int key; }Elem;typedef struct {int key;//关键字域}ElemType;(3)算法描述int Search_Seq(SSTable ST, int key){//在顺序表ST中顺序查找其关键字等于key的数据元素。
数据结构中的查找算法总结静态查找是数据集合稳定不需要添加删除元素的查找包括:1. 顺序查找2. 折半查找3. Fibonacci4. 分块查找静态查找可以⽤线性表结构组织数据,这样可以使⽤顺序查找算法,再对关键字进⾏排序就可以使⽤折半查找或斐波那契查找等算法提⾼查找效率,平均查找长度:折半查找最⼩,分块次之,顺序查找最⼤。
顺序查找对有序⽆序表均适⽤,折半查找适⽤于有序表,分块查找要求表中元素是块与块之间的记录按关键字有序动态查找是数据集合需要添加删除元素的查找包括: 1. ⼆叉排序树 2. 平衡⼆叉树 3. 散列表 顺序查找适合于存储结构为顺序存储或链接存储的线性表。
顺序查找属于⽆序查找算法。
从数据结构线形表的⼀端开始,顺序扫描,依次将扫描到的结点关键字与给定值k相⽐较,若相等则表⽰查找成功 查找成功时的平均查找长度为: ASL = 1/n(1+2+3+…+n) = (n+1)/2 ; 顺序查找的时间复杂度为O(n)。
元素必须是有序的,如果是⽆序的则要先进⾏排序操作。
⼆分查找即折半查找,属于有序查找算法。
⽤给定值value与中间结点mid的关键字⽐较,若相等则查找成功;若不相等,再根据value 与该中间结点关键字的⽐较结果确定下⼀步查找的⼦表 将数组的查找过程绘制成⼀棵⼆叉树排序树,如果查找的关键字不是中间记录的话,折半查找等于是把静态有序查找表分成了两棵⼦树,即查找结果只需要找其中的⼀半数据记录即可,等于⼯作量少了⼀半,然后继续折半查找,效率⾼。
根据⼆叉树的性质,具有n个结点的完全⼆叉树的深度为[log2n]+1。
尽管折半查找判定⼆叉树并不是完全⼆叉树,但同样相同的推导可以得出,最坏情况是查找到关键字或查找失败的次数为[log2n]+1,最好的情况是1次。
时间复杂度为O(log2n); 折半计算mid的公式 mid = (low+high)/2;if(a[mid]==value)return mid;if(a[mid]>value)high = mid-1;if(a[mid]<value)low = mid+1; 折半查找判定数中的结点都是查找成功的情况,将每个结点的空指针指向⼀个实际上不存在的结点——外结点,所有外界点都是查找不成功的情况,如图所⽰。
数据结构顺序查找与折半查找1,顺序查找顺序查找⼜称线性查找,它对顺序表和链表都适⽤。
(1)以下给出相关函数1 typedef struct{2 ElemType *elem; //元素存储空间地址,建表时按实际长度分配,0号单元留空3int TableLen; //表的长度4 }SSTable;5int Search_Seq(SSTable ST,ElemType key)6 {7 ST.elem[0]=key; //把要查找的关键字放在0号位置,称“哨兵”8for(int i=ST.TableLen;ST.elem!=key;i--) //从后往前找9 {10return i; //若表中不存在关键字为key的元素,将查找i=0时退出循环11 }12 }在上述算法中,将ST.elem[0]称为“哨兵”。
引⼊它的⽬的是使得Search_Seq内的循环不必判断数组是否会越界。
因为满⾜i=0时,循环⼀定会跳出。
除此之外,引⼊“哨兵”可以避免很多不必要的判断语句,从⽽提⾼算法的执⾏效率。
(2)算法效率分析当每个元素查找概率相同时,平均查找长度ASL=(n+1)/2, 查找不成功时,需要⽐较整个顺序表,所以⽐较次数时(n+1)次,从⽽顺序查找不成功的平均查找长度为(n+1)。
2.有序表的顺序查找(假设从⼩到⼤排列)有序表的顺序查找成功的平均查找长度与⼀般的线性表⼀样,即(n+1)/2.当查找失败时,待查找的元素为key,当查找第i个元素时,发现第i个元素的对应的关键字⼩于key,但第i+1个元素对应的关键字⼤于key,这时就可以返回查找失败的信息。
查找失败的平均查找长度为ASL=n/2+n/(n+1).3.折半查找前提:折半查找仅适⽤于有序的顺序表。
折半查找原理:将给定的key与中间元素⽐较,直到查到要找的元素。
以下是相关函数1int Binary_Search(SeqList L,ElemType key){2int low=0,high=L.TableLen-1,mid;//low指向表头,high指向表尾,mid中间值3while(low<=high)4 {5 mid=(low+high)/2;6if(L.elem[mid]==key) //中间值等于要查找元素7return mid;8else if(L.elem[mid]<key) //要查找元素在中间值右边9 low=mid+1;10else11 hign=mid-1; //要查找元素在中间值左边12 }13 }查找成功的时间复杂度为log2n,平均情况下⽐顺序查找效率⾼⼀些。
数据结构复习题及答案数据结构习题一、名词解释1.数据、数据元素、数据项、数据结构、数据的逻辑结构、数据物理结构、顺序存储、链式存储、算法、时间复杂度、空间复杂度。
2.线性表、顺序表、单链表、双向链表、循环链表、双向循环链表、三个概念的区别:头指针、头结点、首元结点(第1个元素结点)。
3.栈(顺序栈、链栈)、队列(顺序队、链队)、循环队列、递归、稀疏矩阵、三元组。
4.树、叶子结点、结点的度、树的度、树的高(深)度、二叉树、遍历、满二叉树、完全二叉树、哈夫曼树、WPL、哈夫曼编码。
5.图(有向、无向)、网、边、弧、度、入度、出度、完全图(有向、无向)、(强)连通图(分量)、(最小)生成树、邻接矩阵、邻接表、DFS、BFS。
6.查找表、关键字、静态查找、动态查找、ASL、顺序查找、折半查找、分块查找、二叉排序树。
7、排序、内(外)排序、稳定性、插入(直接、希尔),交换(起泡、快速),选择(直接、堆),2路归并。
一、填空题1.数据结构是研究数据的_逻辑结构__和___物理结构__,并在这种结构上定义相关的运算,设计实现这些运算的算法,分析算法的效率。
算法的效率包括时间和空间两个方面,分别称为___时间复杂度____和__空间复杂度___。
2.数据的基本单元是__数据元素__,数据的最小单元是__数据项_。
3.算法是对特定问题求解___步骤___的一种描述,是指令的有限序列。
4.一个算法的时间复杂度为(3n3+2n—7),其数量级表示为O(n3)_。
5.一个算法具有5个特性:确定性、可行性、有穷性、输入和输出。
6.算法机能的阐发和怀抱,能够从算法的工夫庞大度和空间庞大度来评判算法的好坏。
7.数据的逻辑布局包孕调集布局、线性布局、树形布局和图型布局四品种型。
8.数据布局在计较机中的表示称为数据的物理布局,它能够采用__按次存储___或__链式存储_两种存储方法。
9.线性表有两种存储布局,划分为按次存储和链式存储。
数据结构复习--排序和查找现在正在学习查找和排序,为了节省时间提⾼效率,就正好边学习边整理知识点吧!知识点⼀:⼆分查找/折半查找1.⼆分查找的判定树(选择题)下列⼆叉树中,可能成为折半查找判定树(不含外部结点)的是: (4分)1.2.3.4.注:折半查找判定树是⼀棵⼆叉排序树,它的中序遍历结果是⼀个升序序列,可以在选项中的树上依次填上相应的元素。
虽然折半查找可以上取整也可以下取整但是⼀个查找判定树只能有⼀种取整⽅式。
如果升序序列是偶数个,那么终点应该偏左多右少。
在2选项中,由根节点左⼦树4个节点⽽右⼦树5个节点可以确定⽤的是向下取整策略,但是它的左⼦节点在左⼦树种对应的终点左边2个,右边个,明显是上取整策略,策略没有统⼀,所以是错的。
其他的选项类似分析。
2.⼆分查找法/折半查找法已知⼀个长度为16的顺序表L,其元素按关键字有序排列。
若采⽤⼆分查找法查找⼀个L中不存在的元素,则关键字的⽐较次数最多是: (2分)1. 72. 63. 54. 4 注:⼀次找到最边界的那⼀个树的情况下有最多次数 这个题中结点数16是个偶数:第⼀次(0+15)/2 7 第⼆次(8+15)/2 11第三次(12+15)/2 14 第四次(14+15)/2 14 第五次(15+15)/2 15(下取整的就向右计算求最多次数)第⼀次(0+15)/2 8 第⼆次(0+7)/2 4 第三次(0+3)/2 2 第四次(0+1)/2 0第五次(0+0)/2 0(下取整的话就向左求最多次数)若结点数是奇数15:第⼀次(0+14)/2 7 第⼆次( 0+6)/2 3 第三次(0+2)/2 1第四次(0+0)/2 0第⼀次(0+14)/2 7 第⼆次(8+14)/2 11 第三次(12+14)/2 13第四次(14+14)/2 0这时候向左或者向右都是OK的(因为得到的数都是能够被2整除的)但是划重点了折半查找⼀个有序表中不存在的元素,若向下取整,则要最多⽐较[log2n]+1次,若向上取整,则要最多⽐较[log2(n+1)],其实就是求树的深度.(这⼀块⾃⼰的说法可能不够准确,希望⼤家看到有问题的可以指出来)结合实际,我们⽤[log2n]+1来算更简单并且计算[log2n]要取整数,因为可能会存在不是满⼆叉树的情况。
数据结构二叉排序树数据结构二叉排序树1. 概述二叉排序树(Binary Search Tree,简称BST)是一种基于二叉树的数据结构,具有以下特点:- 每个节点最多只有两个子节点。
- 对于树中的任意节点,其左子树上所有节点的值都小于该节点的值,右子树上所有节点的值都大于该节点的值。
- 中序遍历二叉排序树得到的结果是一个有序序列。
2. 二叉排序树的操作2.1 插入二叉排序树的插入操作是将一个新的节点插入到二叉排序树中的合适位置,使得二叉排序树仍然满足以上特点。
插入操作的具体步骤如下:1. 若二叉排序树为空树,则将新节点作为根节点插入即可。
2. 若二叉排序树不为空,比较新节点的值与当前节点的值的大小关系:- 若新节点的值小于当前节点的值,则继续在当前节点的左子树中进行插入操作。
- 若新节点的值大于当前节点的值,则继续在当前节点的右子树中进行插入操作。
2.2 删除二叉排序树的删除操作是将指定节点从二叉排序树中删除,并保持二叉排序树的特性不变。
删除操作的具体步骤如下:1. 若待删除节点为叶子节点,则直接将其父节点指向该节点的指针置为null。
2. 若待删除节点只有左子树或只有右子树,则将其父节点指向该节点的指针直接指向该节点的子节点。
3. 若待删除节点既有左子树又有右子树,则需要找到其右子树中的最小节点(或左子树中的最大节点)来替代待删除节点。
具体步骤如下:- 先找到待删除节点右子树中的最小节点(即右子树中最左下的节点),或者左子树中的最大节点。
- 将该最小(或最大)节点的值复制到待删除节点。
- 将最小(或最大)节点从右子树(或左子树)中删除。
2.3 查找二叉排序树的查找操作是在树中寻找具有指定值的节点。
查找操作的具体步骤如下:1. 从根节点开始,将待查找的值与当前节点的值进行比较。
2. 若待查找的值等于当前节点的值,则返回该节点。
3. 若待查找的值小于当前节点的值,则继续在当前节点的左子树中进行查找操作。
折半查找判定树的特点折半查找判定树,也称为二叉判定树或二分判定树,是一种用于快速查找的数据结构。
它主要用于在有序序列中进行二分查找,其特点是具有平衡性和高效性。
以下将详细介绍折半查找判定树的特点。
1.平衡性:折半查找判定树具有平衡性,即左子树和右子树的高度差不超过1。
这意味着在进行二分查找时,每次都能将查找区域均匀地划分为两部分,使得查找的效率更高。
平衡性也能够确保树的高度较小,提高查找的速度。
2.有序性:折半查找判定树中的节点按照某种顺序排列,通常是按照节点值的大小顺序。
这意味着在查找过程中,可以利用节点的有序性,通过比较节点的值来确定查找的方向。
这种有序性可以大大减少查找的次数,提高查找的效率。
3.高效性:由于折半查找判定树具有平衡性和有序性,因此在进行查找时,可以通过比较节点的值来确定查找的方向,从而快速缩小查找的范围。
在每一次比较之后,查找的区域都会减半,使得查找的效率非常高。
在最坏情况下,折半查找的时间复杂度为O(logn),其中n为查找区域的大小。
4.空间效率:折半查找判定树的存储结构是二叉树,相对于其他数据结构如平衡二叉树或红黑树来说,它的空间占用较小。
由于其平衡性,递归创建查找树时不会出现斜树的情况,因此不会浪费大量的空间。
同时,折半查找判定树不需要额外的存储结构,只需存储节点的值和指向左右子树的指针,因此空间效率较高。
5.插入和删除操作复杂度较高:折半查找判定树的插入和删除操作比较复杂,需要涉及到节点的平衡调整。
当插入或删除一个节点时,需要找到插入或删除位置的父节点,并修改指向左右子树的指针。
为了保持平衡性,可能需要进行旋转操作,即左旋或右旋。
这些操作可能引起多次旋转,因此插入和删除操作的时间复杂度较高。
6.查询效率高:由于折半查找判定树具有平衡性和有序性,能够快速确定查找的方向,并缩小查找的范围,因此在查找操作中具有高效的查询效率。
当数据规模较大时,通过折半查找判定树进行查找可以大幅减少比较的次数,提高查询效率。
数据结构中的树、图、查找、排序在计算机科学中,数据结构是组织和存储数据的方式,以便能够有效地对数据进行操作和处理。
其中,树、图、查找和排序是非常重要的概念,它们在各种算法和应用中都有着广泛的应用。
让我们先来谈谈树。
树是一种分层的数据结构,就像是一棵倒立的树,有一个根节点,然后从根节点向下延伸出许多分支节点。
比如一个家族的族谱,就可以用树的结构来表示。
最上面的祖先就是根节点,他们的后代就是分支节点。
在编程中,二叉树是一种常见的树结构。
二叉树的每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉搜索树是一种特殊的二叉树,它具有特定的性质,即左子树中的所有节点值都小于根节点的值,而右子树中的所有节点值都大于根节点的值。
这使得在二叉搜索树中查找一个特定的值变得非常高效。
二叉搜索树的插入和删除操作也相对简单。
插入时,通过比较要插入的值与当前节点的值,确定往左子树还是右子树移动,直到找到合适的位置插入新节点。
删除节点则稍微复杂一些,如果要删除的节点没有子节点,直接删除即可;如果有一个子节点,用子节点替换被删除的节点;如果有两个子节点,通常会找到右子树中的最小节点来替换要删除的节点,然后再删除那个最小节点。
接下来,我们聊聊图。
图是由顶点(也称为节点)和边组成的数据结构。
顶点代表对象,边则表示顶点之间的关系。
比如,社交网络中的用户可以看作顶点,用户之间的好友关系就是边。
图可以分为有向图和无向图。
有向图中的边是有方向的,就像单行道;无向图的边没有方向,就像双向车道。
图的存储方式有邻接矩阵和邻接表等。
邻接矩阵用一个二维数组来表示顶点之间的关系,如果两个顶点之间有边,对应的数组元素为 1,否则为 0。
邻接表则是为每个顶点建立一个链表,链表中存储与该顶点相邻的顶点。
图的遍历是图算法中的重要操作,常见的有深度优先遍历和广度优先遍历。
深度优先遍历就像是沿着一条路一直走到底,然后再回头找其他路;广度优先遍历则是先访问距离起始顶点近的顶点,再逐步扩展到更远的顶点。
查找算法:⼆叉排序树⼆叉排序树,⼜称⼆叉查找树,是⼀种对排序和查找都很有⽤的特殊⼆叉树1. 定义⼆叉排序树或者是⼀棵空树,或者具有以下定义:1)若左⼦树不为空,左⼦树上所有结点值均⼩于根结点值;2)若右⼦树不为空,右⼦树上所有结点值均⼤于根结点值;3)左右⼦树也分别为⼆叉排序树。
递归定义。
有定义可得性质:中序遍历⼆叉树可得到结点递增的有序序列。
2. 查找模仿折半查找易得⾮递归查找算法,以下给出递归形式BSTree searchBST(BSTree T, KeyType key) {if (!T || T.data == key) return T; // 找到则返回T,找不到则返回空else if (T.data < key) return SearchBST(T.right, key);else return SearchBST(T.left, key);}算法分析:⼆叉排序树上的查找和折半查找相差不⼤。
但⼆叉排序树可更好地维护表的有序性,⽆需移动记录,只需移动指针即可完成插⼊和删除操作。
因此,对需要经常进⾏插⼊、删除和查找运算的表,采⽤⼆叉排序树⽐较好。
3. 插⼊当树中不存在关键字等于key的结点时才进⾏插⼊。
新插⼊的结点⼀定是⼀个新添加的叶⼦结点(?⼀定是叶⼦结点?),且是查找不成功时查找路径上访问的最后⼀个结点的左孩⼦或右孩⼦节点。
void insertBST(BSTree T, ElementType e) {if (!T) {S = new BSTNode;S.data = e;S.lchild = S.rchild = NULL;T = S;}else if (T.data > e.data) insertBST(T.lchild, e);else if (T.data < e.data) insertBST(T.rchild, e);}4. 创建void createBST(BSTree T) {T = NULL;cin>>e; // 输⼊ewhile(e.key != ENDFLAG){ // ENDFLAG为⾃定义常量,作为输⼊结束标志insertBST(T, e);cin>>e;}}5. 删除(待补充......)。
数据结构-⼆叉搜索树判断题1.在⼀棵⼆叉搜索树上查找63,序列39、101、25、80、70、59、63是⼀种可能的查找时的结点值⽐较序列。
T F2.在⼀棵由包含4、5、6等等⼀系列整数结点构成的⼆叉搜索树中,如果结点4和6在树的同⼀层,那么可以断定结点5⼀定是结点4和6的⽗亲结点。
3.⼆叉搜索树的查找和折半查找的时间复杂度相同。
只有平衡的⼆叉搜索树才与折半查找时间复杂度相同4.⼆叉搜索树的最⼩元素⼀定位于树根的左⼦树。
T F还可能是根结点选择题1.对⼆叉搜索树进⾏什么遍历可以得到从⼩到⼤的排序序列?A.前序遍历B.后序遍历中序遍历层次遍历2.在有N个结点且为完全⼆叉树的⼆叉搜索树中查找⼀个键值,其平均⽐较次数的数量级为:A.O(logN)B.O(N)C.O(NlogN)D.O(N2)3.已知8个数据元素为(34,76,45,18,26,54,92,65),按照依次插⼊结点的⽅法⽣成⼀棵⼆叉搜索树后,最后两层上的结点总数为:A.1D.44.将{28, 15, 42, 18, 22, 5, 40}依次插⼊初始为空的⼆叉搜索树。
则该树的后序遍历结果是:A.5, 15, 18, 22, 40, 42, 28B.5, 22, 15, 40, 18, 42, 28C.28, 22, 18, 42, 40, 15, 5D.5, 22, 18, 15, 40, 42, 285.将{5, 2, 7, 3, 4, 1, 6}依次插⼊初始为空的⼆叉搜索树。
则该树的后序遍历结果是:A.1, 2, 3, 4, 6, 7, 5B.1, 4, 2, 6, 3, 7, 56.若⼀棵⼆叉树的前序遍历序列是{ 4, 2, 1, 3, 6, 5, 7 },中序遍历序列是{ 1, 2, 3, 4, 5, 6, 7 },则下列哪句是错的?A.这是⼀棵完全⼆叉树B.所有的奇数都在叶⼦结点上C.这是⼀棵⼆叉搜索树是5的⽗结点7.将{ 6, 9, 12, 3, 4, 8 }依次插⼊初始为空的⼆叉搜索树。
数据结构二叉排序树二叉排序树(Binary Search Tree)是一种特殊的二叉树,又称二叉查找树或二叉搜索树。
它的左子树上所有结点的值均小于它的根结点的值,右子树上所有结点的值均大于它的根结点的值。
并且左、右子树也分别是二叉排序树。
二叉排序树的实现,通常使用链式存储结构。
每个节点包含三个数据成员:key,left和right。
key为节点的关键字,left和right分别表示左右孩子节点的指针。
二叉排序树的查找过程是从根节点开始,比较要查找的关键字和根节点的关键字的大小,如果相等,则找到所需节点;如果比根节点小,则在左子树中继续查找;如果比根节点大,则在右子树中继续查找,直到找到所需节点或者指针为空。
二叉排序树的插入过程是先进行查找操作,找到插入的位置后,在该位置插入新节点。
插入一个新的节点会改变原有的结构,需要不断地调整二叉排序树,使之重新满足二叉排序树定义的性质。
二叉排序树的删除过程比较复杂,需要考虑多种情况。
如果要删除的节点是叶子节点,直接删除即可;如果要删除的节点只有一个子节点,将其子节点替换成该节点即可;如果要删除的节点有两个子节点,需要找到其右子树中的最小节点或者左子树中的最大节点作为替代节点。
二叉排序树的优缺点:优点:1. 查找、插入、删除元素的操作复杂度均为O(log n),比线性查找的复杂度O(n)要快。
2. 适用于查找、排序、统计和检索大量元素的应用场景,例如字典、电话簿等。
3. 在存储元素的过程中,可以任意添加或删除元素,不会导致其他元素的位序改变。
4. 这种数据结构利用了树的优点,非常适合用于内存有限的情况下。
缺点:1. 当元素的排序规则不合理时,二叉排序树可能导致树的深度较大,从而影响操作效率。
2. 二叉排序树的构造过程是顺序插入的,可能会造成树的不平衡,进而影响操作效率。
3. 二叉排序树对于相同元素的重复插入会导致树的深度增大,从而影响操作效率。
总结:二叉排序树是一种优秀的数据结构,用于排序和查找元素的操作。
折半查找和二叉排序树一、实验目的1、掌握查找的特点。
2、掌握折半查找的基本思想及其算法。
3、熟悉二叉排序树的特点,掌握二叉排序树的插入、删除操作。
二、实验内容1、设有关键字序列k={ 5 ,14 ,18 ,21 ,23 ,29 ,31 ,35 },查找key=21和key=25的数据元素。
2、根据关键字序列{45、24、53、12、37、93}构造二叉排序树,并完成插入13删除关键字53和24的操作。
三、实验环境TC或VC++或Java四、实验步骤1、折半查找(1)从键盘输入上述8个整数5 ,14 ,18 ,21 ,23 ,29 ,31 ,35,存放在数组bub[8]中,并输出其值。
(2)从键盘输入21,查找是否存在该数据元素,若存在,则输出该数据元素在表中的位置,否则给出查找失败的信息。
(3)从键盘输入25,查找是否存在该数据元素,若存在,则输出该数据元素在表中位置,否则给出查找失败的信息。
2、二叉排序树(1)二叉排序树存储定义(2)从键盘上输入六个整数45、24、53、12、37、9构造二叉排序树(3)输出其中序遍历结果。
(4)插入数据元素13,输出其中序遍历结果。
(5)删除数据元素24和53,输出其中序遍历结果。
五、问题讨论1、折半查找递归算法该怎么描述?2、二叉排序树中序遍历结果有什么特点?3、在二叉树排序树中插入一个新结点,总是插入到叶结点下面吗?4、在任意一棵非空二叉排序树中,删除某结点后又将其插入,则所得二排序叉树与原二排序叉树相同吗?六、实验报告内容1、实验目的2、实验内容和具体要求3、完成情况和实验记录,实验记录为实验过程中遇到的问题及解决方法4、程序清单5、所输入的数据及相应的运行结果6、问题回答7、实验心得实验代码:#include<stdio.h>#include<stdlib.h>typedef struct BiTNode{int data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int bub[100];void menu(){printf("********主目录*******\n");printf(" 折半或顺序查找1\n");printf(" 二叉排序树2\n");printf(" 结束程序0\n");printf("*********************\n");}void menu1(){printf("*******目录①*******\n");printf(" 输出元素1\n");printf(" 顺序查找2\n");printf(" 折半查找3\n");printf(" 结束此查找0\n");printf("********************\n");}void menu2(){printf("**********目录②*********\n");printf("输出树的中序遍历结果1\n");printf(" 插入数据元素2\n");printf(" 删除数据元素3\n");printf(" 结束二叉排序0\n");printf("*************************\n"); }void Search(){int i,m,n,key,k;printf("输入元素个数:");scanf("%d",&m);printf("依次输入元素:");for(i=1;i<=m;i++){scanf("%d",&bub[i]);}printf("输入关键字:");scanf("%d",&key);bub[0] = key;do{menu1();printf("选择查找方式:");scanf("%d",&n);switch(n){case 1:for(i=1;i<=m;i++){printf("%d,",bub[i]);}printf("\n");break;case 2:for(i=m;i>=0;i--){if(bub[i]==key){if(i!=0){printf("查找的数据元素在第%d位!\n",i);break;}else{printf("查找失败\n");}}}break;case 3:k = Search_Bin(m,key);if(k!=0)printf("查找的数据元素在第%d位!\n",k);elseprintf("查找失败\n");break;case 0:printf("查找结束\n");break;default:printf("选择错误\n");}}while(n!=0);}int Search_Bin(int m,int key){int low,high,mid;low = 1;high = m;while(low<=high){mid = (low+high)/2;if(key==bub[mid])return mid;else if(key<bub[mid])high = mid-1;elselow = mid+1;}return 0;}BiTree Insert(){BiTree T=NULL,q=NULL,p=NULL;int m;printf("输入数据(-10000停止输入):");scanf("%d",&m);while(m!=-10000){q = (BiTree)malloc(sizeof(BiTNode));q->data = m;q->lchild = q->rchild=NULL;if(!T)T = q;else{p = T;while(1){if(m<p->data){if(p->lchild==NULL){p->lchild = q;break;}p = p->lchild;}else{if(p->rchild==NULL){p->rchild = q;break;}p = p->rchild;}}}scanf("%d",&m);}return T;}void Inorder(BiTree T){if(T){Inorder(T->lchild);printf("%d,",T->data);Inorder(T->rchild);}}int Search_CH(BiTree T,int elem,BiTree f,BiTree *p) {if(!T){*p = f;return 0;}else if(elem==T->data){*p = T;return 1;}else if(elem<T->data)Search_CH(T->lchild,elem,T,p);elseSearch_CH(T->rchild,elem,T,p);}BiTree InsertBST(BiTree T,int elem){BiTree p=NULL,s=NULL;if(!Search_CH(T,elem,NULL,&p)){s = (BiTree)malloc(sizeof(BiTNode));s->data = elem;s->lchild = s->rchild = NULL;if(!p)T = s;else if(elem<p->data)p->lchild = s;elsep->rchild = s;printf("插入成功\n");return T;}printf("输入已有元素,插入失败\n");return T;}BiTree Delete(BiTree T,int elem){BiTree p=NULL,q=NULL,f=NULL,s=NULL;p = T;while(p){if(elem == p->data)break;q = p;if(elem <p->data)p = p->lchild;elsep = p->rchild;}if(!p)printf("查找失败,删除失败\n");return T;}if(!(p->lchild)){if(!q)T = p->rchild;else if(q->lchild == p)q->lchild = p->rchild;elseq->rchild = p->rchild;free(p);}else{f = p;s = p->lchild;while(s->rchild){f = s;s = s->rchild;}if(f==p)f->lchild = s->lchild;elsef->rchild = s->lchild;p->data = s->data;free(s);}printf("删除成功\n");return T;}void ErChaPaiXu(){BiTree T;int m,key;T = Insert();domenu2();printf("输入你的选择:");scanf("%d",&m);switch(m){case 1:printf("中序遍历结果为:");Inorder(T);printf("\n");break;case 2:printf("输入要插入的元素:");scanf("%d",&key);T = InsertBST(T,key);break;case 3:printf("输入要删除的元素:");scanf("%d",&key);T = Delete(T,key);break;case 0:printf("结束二叉排序\n");break;default:printf("输入错误\n");}}while(m!=0);}void main(){int m;do{menu();printf("输入你的选择:");scanf("%d",&m);switch(m){case 1:Search();break;case 2:ErChaPaiXu();break;case 0:printf("程序已结束\n");break;default:printf("输入错误\n");}}while(m!=0);}。
二叉排序树
#include "c1.h"
#include "stdio.h"
#include "stdlib.h"
typedef int KeyType;
typedef struct node{
KeyType key;
struct node *lchild,*rchild;
}BiTNode,*BiTree;
void InsertBST(BiTree &bst,KeyType key)
{
BiTNode *t;
if(bst==NULL)
{
t=(BiTree)malloc(sizeof(BiTNode));
t->key=key;
t->lchild=NULL;
t->rchild=NULL;
bst=t;
}
else if(key<bst->key)
InsertBST(bst->lchild,key);
else if(key>bst->key)
InsertBST(bst->rchild,key);
}
void CreateBST(BiTree &bst)
{
int i;
int n;
KeyType key=0;
bst=NULL;
printf("请输入二叉排序树中元素的个数:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("请输入二叉排序数中的第%d个元素:",i);
scanf("%d",&key);
InsertBST(bst,key);
}
}
BiTree SearchBST(BiTree bst,KeyType key)
{
if(!bst)
return NULL;
else if(bst->key==key)
return bst;
else if(key<bst->key)
return SearchBST(bst->lchild,key);
else
return SearchBST(bst->rchild,key);
}
int main()
{
BiTree bst;
CreateBST(bst);
KeyType temp;
printf("请输入你要查找的元素:");
scanf("%d",&temp);
BiTree T;
T=SearchBST(bst,temp);
if(T==NULL)
printf("\n\n查找失败\n");
else
{
printf("\n\n查找成功\n");
printf("二叉排序树中查到的元素为:%d\n",T->key);
}
}
折半查找和顺序查找
#include "stdio.h"
#include "stdlib.h"
#include "c1.h"
#define N 20
typedef struct
{
int Key;
}ElemType;
typedef struct SSTable {
ElemType *elem;
int length;
}SSTable;
int Search_Seq(SSTable ST,int Key)
{
int i;
ST.elem[0].Key=Key;
for(i=ST.length;ST.elem[i].Key!=Key;i--);
return i;
}
int count;
int Search_Bin(SSTable ST,int Key)
{
int low=1;
int high=ST.length;
int mid;
count=0;
while(low<=high)
{
count++;
mid=(low+high)/2;
if(ST.elem[mid].Key==Key)
return mid;
else if(Key<ST.elem[mid].Key)
high=mid-1;
else
low=mid+1;
}
return 0;
}
int main()
{
SSTable ST;
ST.elem=(ElemType *)malloc(N*sizeof(ElemType));
if(!ST.elem)
exit(0);
int len;
printf("请输入查找表的长度:");
scanf("%d",&len);
int i;
printf("请按顺序输入表中元素:");
for(i=1;i<=len;i++)
scanf("%d",&ST.elem[i].Key);
ST.length=len;
int key=0;
while (key!=-1)
{printf("请输入你要查找的关键字:");
scanf("%d",&key);
if(key==-1)
break;
printf("顺序查找的查找结果为: %d\n",Search_Seq(ST,key));
printf("顺序查找的次数为: %d\n",ST.length-Search_Seq(ST,key)+1);
printf("二分查找的查找结果为:%d\n",Search_Bin(ST,key));
printf("二分查找的次数为:%d\n",count);
}
}。