数据结构-实验4-建立AVL树
数据结构模拟试题(1)
(1)
(2)
(3)
(4)
参考答案：
(0) [30 18 20 15 38 12 44 53 46 18* 26 86]
(1) [18 30][15 20][12 38][44 53][18* 46][26 86]
(2) [15 18 20 30][12 38 44 53][18* 26 46 86]
A:n-I B:n-I+1
C:n-i-1 D:I
7、 不带头结点的单链表first为空的判定条件是( )。
A:first == NULL; B:first->link == NULL;
C:first->link == first; D:D. first != NULL;
8、 树中所有结点的度之和等于所有结点数加( )。
A:0 B:1
C:－1 D:2
9、 一棵具有35个结点的完全二叉树的高度为( )。假定空树的高度为 -1。
A:5 B:6
C:7 D:8
数据结构模拟试题（1）
一、填空题:06分，每题02分
1、 从一个具有n个结点的单链表中搜索其值等于x的结点时, 在搜索成功的情况下, 需平均比较_______次。
2、 根据一组记录(56,42,50,64,48)依次插入结点生成一棵AVL树时，当插入到值为_______的结点时需要进行旋转调整。
31、 已知一个数据表为{48,25,56,32,40}，请写出在进行快速排序的过程中每次划分后数据表的变化。
(0) [48 25 56 32 40]
(1)
(2)
(3)
参考答案：
(0) [48 25 56 32 40]
数据结构树的实验报告
数据结构树的实验报告数据结构树的实验报告一、引言数据结构是计算机科学中的重要概念，它可以帮助我们组织和管理数据，提高程序的效率和性能。
而树作为一种常见的数据结构，具有广泛的应用。
本实验旨在通过实践操作，深入理解树的基本概念、特性和操作。
二、实验目的1. 掌握树的基本概念和特性；2. 熟悉树的基本操作，如插入、删除、查找等；3. 理解树的遍历算法，包括前序、中序和后序遍历；4. 实现树的基本功能，并验证其正确性和效率。
三、实验过程1. 构建树的数据结构首先，我们需要定义树的数据结构。
树由节点组成，每个节点可以有零个或多个子节点。
我们可以使用面向对象的思想，创建一个节点类和树类。
节点类包含节点值和子节点列表的属性，以及插入、删除子节点等操作的方法。
树类则包含根节点的属性和遍历方法等。
2. 插入和删除节点在树中插入和删除节点是常见的操作。
插入节点时，我们需要找到合适的位置，并将新节点作为子节点添加到相应的位置。
删除节点时，我们需要考虑节点的子节点和兄弟节点的关系，并进行相应的调整。
通过实现这两个操作，我们可以更好地理解树的结构和特性。
3. 查找节点树中的节点可以通过值进行查找。
我们可以使用递归或迭代的方式，在树中进行深度优先或广度优先的搜索。
在查找过程中，我们需要注意节点的存在性和唯一性，以及查找算法的效率。
4. 树的遍历树的遍历是指按照一定的顺序访问树中的所有节点。
常见的遍历方式有前序、中序和后序遍历。
前序遍历先访问根节点，然后递归地访问左子树和右子树；中序遍历先递归地访问左子树，然后访问根节点，最后访问右子树；后序遍历先递归地访问左子树和右子树，最后访问根节点。
通过实现这三种遍历算法，我们可以更好地理解树的结构和遍历过程。
五、实验结果与分析通过实验，我们成功地实现了树的基本功能，并验证了其正确性和效率。
我们可以通过插入和删除节点操作，构建出不同形态的树，并进行查找和遍历操作。
在插入和删除节点时，树的结构会发生相应的变化，但其基本特性仍然保持不变。
数据结构与算法系列研究五——树、二叉树、三叉树、平衡排序二叉树AVL
数据结构与算法系列研究五——树、⼆叉树、三叉树、平衡排序⼆叉树AVL树、⼆叉树、三叉树、平衡排序⼆叉树AVL⼀、树的定义树是计算机算法最重要的⾮线性结构。
树中每个数据元素⾄多有⼀个直接前驱，但可以有多个直接后继。
树是⼀种以分⽀关系定义的层次结构。
a.树是n(≥0)结点组成的有限集合。
{N.沃恩}(树是n(n≥1)个结点组成的有限集合。
{D.E.Knuth})在任意⼀棵⾮空树中：⑴有且仅有⼀个没有前驱的结点----根(root)。
⑵当n>1时，其余结点有且仅有⼀个直接前驱。
⑶所有结点都可以有0个或多个后继。
b. 树是n(n≥0)个结点组成的有限集合。
在任意⼀棵⾮空树中：⑴有⼀个特定的称为根（root）的结点。
⑵当n>1时，其余结点分为ｍ（ｍ≥0）个互不相交的⼦集T1，T2，…，Tm。
每个集合本⾝⼜是⼀棵树，并且称为根的⼦树（subtree）树的固有特性---递归性。
即⾮空树是由若⼲棵⼦树组成，⽽⼦树⼜可以由若⼲棵更⼩的⼦树组成。
树的基本操作1、InitTree(&T) 初始化2、DestroyTree(&T) 撤消树3、CreatTree(&T,F) 按F的定义⽣成树4、ClearTree(&T) 清除5、TreeEmpty(T) 判树空6、TreeDepth(T) 求树的深度7、Root(T) 返回根结点8、Parent(T,x) 返回结点 x 的双亲9、Child(T,x,i) 返回结点 x 的第i 个孩⼦10、InsertChild(&T,&p,i,x) 把 x 插⼊到 P的第i棵⼦树处11、DeleteChild(&T,&p,i) 删除结点P的第i棵⼦树12、traverse(T) 遍历树的结点：包含⼀个数据元素及若⼲指向⼦树的分⽀。
●结点的度: 结点拥有⼦树的数⽬●叶结点: 度为零的结点●分枝结点: 度⾮零的结点●树的度: 树中各结点度的最⼤值●孩⼦: 树中某个结点的⼦树的根●双亲: 结点的直接前驱●兄弟: 同⼀双亲的孩⼦互称兄弟●祖先: 从根结点到某结点j 路径上的所有结点（不包括指定结点）。
AVL树及其平衡性
AVL树及其平衡性AVL树是一种自平衡的二叉搜索树，它得名于它的发明者Adelson-Velsky和Landis。
AVL树在插入和删除节点时会通过旋转操作来保持树的平衡，以确保树的高度始终保持在一个较小的范围内，从而提高搜索、插入和删除操作的效率。
本文将介绍AVL树的基本概念、特点以及如何保持其平衡性。
一、AVL树的基本概念AVL树是一种二叉搜索树，具有以下特点：1. 每个节点最多有两个子节点，左子节点的值小于父节点的值，右子节点的值大于父节点的值；2. 每个节点都有一个平衡因子（Balance Factor），定义为左子树的高度减去右子树的高度；3. AVL树的平衡因子必须为-1、0或1，即任意节点的左右子树高度差不超过1；4. AVL树中任意节点的左子树和右子树都是AVL树。
二、AVL树的平衡性AVL树通过旋转操作来保持树的平衡，主要包括左旋转、右旋转、左右旋转和右左旋转四种操作。
在插入或删除节点后，如果AVL树的平衡因子不满足要求，就需要进行相应的旋转操作来调整树的结构，以保持平衡性。
1. 左旋转（LL旋转）当某个节点的平衡因子为2，且其左子树的平衡因子为1或0时，需要进行左旋转操作。
左旋转是将当前节点向左旋转，使其右子节点成为新的根节点，原根节点成为新根节点的左子节点，新根节点的左子节点成为原根节点的右子节点。
2. 右旋转（RR旋转）当某个节点的平衡因子为-2，且其右子树的平衡因子为-1或0时，需要进行右旋转操作。
右旋转是将当前节点向右旋转，使其左子节点成为新的根节点，原根节点成为新根节点的右子节点，新根节点的右子节点成为原根节点的左子节点。
3. 左右旋转（LR旋转）当某个节点的平衡因子为2，且其左子树的平衡因子为-1时，需要进行左右旋转操作。
左右旋转是先对当前节点的左子节点进行右旋转，然后再对当前节点进行左旋转。
4. 右左旋转（RL旋转）当某个节点的平衡因子为-2，且其右子树的平衡因子为1时，需要进行右左旋转操作。
数据结构,期末考试试卷,复旦大学计算机科学技术学院-2012
7、 分析对比 AVL 树和 Hash 的时空特性，并讨论它们的适合场合。(6 分)
第 7 页
时空特性： AVL 树是高度平衡的二叉查找树，查找时间复杂度为 O(logn)，Hash 的查找时间复杂度为 O(1)。 存储开销 Hash 往往比 AVL 树小。 适合场合： Hash 必须处理冲突，而 AVL 树不存在这种问题。对于删除操作，AVL 树的时间开销很稳定，为 O(logn)，而 Hash，如果采用拉链法处理冲突，则删除操作易于实现，如果采用开放定址法，则 删除操作很难实现，因此开放定址法的 Hash 不适合更新频繁的数据存储。另外，AVL 树对数据 的存储是有序的，而 Hash 对数据的存储并不能反映数据之间的大小关系。因此，AVL 树适用于 有序的数据存储，而 Hash 适用于数据量比较大且分布比较均匀，对数据排序无要求的数据存储。
专业
题号 得分
学号
一 二 三
姓名
四 总分
成绩
一、填空题（25%,1~8 题每题 2 分）
（ 装 订 线 内 不 要 答 题 ） 1、 设 W 为一个二维数组，其每个数据元素占用 4 个字节，行下标 i 从 0 到 7 ，列下标 j 从 0 到 3 ，则二维数组 W 的数据元素共占用 个字节。若按行顺序存放二维数组 W，其起 始地址为 100(10 进制)，则二维数组元素 W[6，3]的起始地址为 （10 进制表示） 。 答：128, 208。 2、 后缀算式 9 2 3 + - 10 2 / - 的值为__________。中缀算式（3+4X）-2Y/3 对应的后缀算 式为_______________________________。 答：-1, 3 4 X * + 2 Y * 3 / -。
数据结构二叉树的实验报告
数据结构二叉树的实验报告数据结构二叉树的实验报告一、引言数据结构是计算机科学中非常重要的一个领域，它研究如何组织和存储数据以便高效地访问和操作。
二叉树是数据结构中常见且重要的一种，它具有良好的灵活性和高效性，被广泛应用于各种领域。
本实验旨在通过实际操作和观察，深入了解二叉树的特性和应用。
二、实验目的1. 理解二叉树的基本概念和特性；2. 掌握二叉树的创建、遍历和查找等基本操作；3. 通过实验验证二叉树的性能和效果。
三、实验过程1. 二叉树的创建在实验中，我们首先需要创建一个二叉树。
通过输入一系列数据，我们可以按照特定的规则构建一棵二叉树。
例如，可以按照从小到大或从大到小的顺序将数据插入到二叉树中，以保证树的有序性。
2. 二叉树的遍历二叉树的遍历是指按照一定的次序访问二叉树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历是先访问根节点，然后再依次遍历左子树和右子树；中序遍历是先遍历左子树，然后访问根节点，最后再遍历右子树；后序遍历是先遍历左子树，然后遍历右子树，最后访问根节点。
3. 二叉树的查找二叉树的查找是指在二叉树中寻找指定的节点。
常见的查找方式有深度优先搜索和广度优先搜索。
深度优先搜索是从根节点开始，沿着左子树一直向下搜索，直到找到目标节点或者到达叶子节点；广度优先搜索是从根节点开始，逐层遍历二叉树，直到找到目标节点或者遍历完所有节点。
四、实验结果通过实验，我们可以观察到二叉树的特性和性能。
在创建二叉树时，如果按照有序的方式插入数据，可以得到一棵平衡二叉树，其查找效率较高。
而如果按照无序的方式插入数据，可能得到一棵不平衡的二叉树，其查找效率较低。
在遍历二叉树时，不同的遍历方式会得到不同的结果。
前序遍历可以用于复制一棵二叉树，中序遍历可以用于对二叉树进行排序，后序遍历可以用于释放二叉树的内存。
在查找二叉树时，深度优先搜索和广度优先搜索各有优劣。
深度优先搜索在空间复杂度上较低，但可能会陷入死循环；广度优先搜索在时间复杂度上较低，但需要较大的空间开销。
avl的引入流程
avl的引入流程AVL树是一种自平衡二叉树，它通过旋转操作来保持树的平衡，确保任何节点的左子树和右子树的高度差最多为1、在引入AVL树的过程中，需要进行如下几个步骤：1.引入背景：首先，我们需要说明引入AVL树的背景和初衷。
AVL树的概念最早由G.M. Adelson-Velsky和E.M. Landis在1962年提出，他们希望通过这种数据结构来提高和插入操作的平均和最糟糕情况下的时间复杂度。
2.定义：接下来，我们需要定义AVL树的性质和操作。
AVL树是一种二叉树，它具有以下几个特点：-每个节点最多有两个子节点。
-左子树和右子树的高度差最多为1-每个节点的值大于其左子树中所有节点的值，小于其右子树中所有节点的值。
3.插入操作：在向AVL树中插入新节点时，需要进行一系列的旋转操作来保持树的平衡。
插入操作的过程如下：-首先，我们需要将新节点插入到合适的位置，使得树仍然保持二叉树的性质。
-然后，我们从插入点开始向上遍历，检查每个祖先节点是否平衡。
如果祖先节点不平衡，需要进行旋转操作来调整平衡。
-旋转操作分为两种类型：左旋和右旋。
左旋可以平衡右子树比左子树高的情况，右旋可以平衡左子树比右子树高的情况。
通过旋转操作，我们可以将不平衡的子树转换为平衡的子树。
-当所有祖先节点都平衡时，整个插入操作完成。
4.删除操作：在从AVL树中删除节点时，也需要进行一系列的旋转操作来保持树的平衡。
删除操作的过程如下：-首先，我们需要找到要删除的节点。
如果节点不存在，则删除操作完成。
-如果要删除的节点有两个子节点，可以选择用其前驱或后继节点替换它，并将要删除的节点变为其前驱或后继节点。
-删除节点后，我们需要从删除点开始向上遍历，检查每个祖先节点是否平衡。
如果祖先节点不平衡，需要进行旋转操作来调整平衡。
-同样，旋转操作分为左旋和右旋，以调整平衡。
-当所有祖先节点都平衡时，整个删除操作完成。
5.性能分析：最后，我们需要对AVL树的性能进行分析。
数据结构 实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程，通过本次实验，旨在加深对常见数据结构（如链表、栈、队列、树、图等）的理解和应用，提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
操作系统为 Windows 10。
三、实验内容1、链表的实现与操作创建一个单向链表，并实现插入、删除和遍历节点的功能。
对链表进行排序，如冒泡排序或插入排序。
2、栈和队列的应用用栈实现表达式求值，能够处理加、减、乘、除和括号。
利用队列实现银行排队系统的模拟，包括顾客的到达、服务和离开。
3、二叉树的遍历与操作构建一棵二叉树，并实现前序、中序和后序遍历。
进行二叉树的插入、删除节点操作。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历。
四、实验步骤及结果1、链表的实现与操作首先，定义了链表节点的结构体：｀｀｀cppstruct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；｀｀｀插入节点的函数：｀｀｀cppvoid insertNode(ListNode& head, int val) ｛ListNode newNode ＝ new ListNode(val)；head ＝ newNode;｝ else ｛ListNode curr ＝ head;while （curr>next!＝ NULL) ｛curr ＝ curr>next;｝curr>next ＝ newNode;｝｝｀｀｀删除节点的函数：｀｀｀cppvoid deleteNode(ListNode& head, int val) ｛if （head ＝＝ NULL) ｛return;｝ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;while （curr>next!＝ NULL ＆＆ curr>next>data!＝ val) ｛curr ＝ curr>next;｝if （curr>next!＝ NULL) ｛ListNode temp ＝ curr>next;curr>next ＝ curr>next>next;delete temp;｝｝｀｀｀遍历链表的函数：｀｀｀cppvoid traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛std:：cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝std:：cout ＜＜ std:：endl;｝｀｀｀对链表进行冒泡排序的函数：｀｀｀cppvoid bubbleSortList(ListNode& head) ｛if （head ＝＝ NULL ｜｜ head>next ＝＝ NULL) ｛return;｝bool swapped;ListNode ptr1;ListNode lptr ＝ NULL;do ｛swapped ＝ false;ptr1 ＝ head;while （ptr1-＞next!＝ lptr) ｛if （ptr1-＞data ＞ ptr1-＞next>data) ｛int temp ＝ ptr1-＞data;ptr1-＞data ＝ ptr1-＞next>data;ptr1-＞next>data ＝ temp;swapped ＝ true;｝ptr1 ＝ ptr1-＞next;｝lptr ＝ ptr1;｝ while （swapped)；｝｀｀｀测试结果：创建了一个包含 5、3、8、1、4 的链表，经过排序后，输出为 1 3 4 5 8 。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
哈尔滨工业大学计算机科学与技术学院实验报告课程名称：数据结构与算法课程类型：必修实验项目名称：查找结构与排序算法实验题目：建立A VL树目录目录 (2)一、实验目的 (3)二、实验要求及实验环境 (3)1.实验要求： (3)2.实验环境： (3)三、设计思想 (3)1．逻辑设计 (3)(1)平衡查找二叉树 (3)(2)平衡因子 (4)(3)失衡情况与修正操作 (4)2．物理设计 (5)(1)存储结构 (5)(2)建立平衡二叉查找树 (6)(3)插入新结点 (6)(4)删除结点 (11)四、测试结果 (15)五、系统不足与经验体会 (15)六、附录：源代码（带注释） (16)一、实验目的通过实现A VL树的建立、插入与删除，掌握A VL树结构。
二、实验要求及实验环境1.实验要求：要求：1.具有插入（建立）、删除和查找功能2.插入操作应包括四种类型的平衡化处理3.删除操作应包括四种类型的平衡化处理并且包括多次平衡化处理4.能体现操作前后二叉树的形态及其变化2.实验环境：Microsoft Windows7, Code：：Blocks 10.05三、设计思想1．逻辑设计(1)平衡查找二叉树平衡二叉树的定义是：平衡二叉树或为空树，或满足下列特征：A若其左子树非空，则左子树上所有结点的关键字值都小于根节点关键字值B若其右子树非空，则右子树上所有结点的关键字值都大于根节点关键字值C根节点的左右子树高度之差的绝对值不超过1D根节点的左子树和右子树仍为A VL树平衡查找二叉树不会退化为线性链表，因此时间复杂度比较稳定。
(2)平衡因子为了更好地实现平衡查找二叉树，引进平衡因子Balanced Factor。
平衡因子的值为一个结点的左子树与右子树的高度之差，对于A VL树中的结点而言，BF只能是-1,0,和1。
当插入或删除操作导致平衡二叉查找树的某个结点的平衡因子偏离正确范围时，就可以及时进行修正操作，以保证二叉树保持平衡。
(3)失衡情况与修正操作从平衡二叉查找树出发，插入或删除某个结点后，二叉树失衡，从最底层结点来看只有四种可能：LL型：新结点插入到根节点的左子树的左子树上导致失衡。
对这种情况，应该顺时针旋转原树并进行相应修改：RR型：新结点插入到根节点的右子树的右子树上导致失衡。
对这种情况，应该顺时针旋转原树并进行相应修改：LR型：新结点插入到根节点的左子树的右子树上导致失衡。
对这种情况，应该先逆时针再顺时针旋转原树并进行相应修改：RL型：新结点插入到根节点的右子树的左子树上导致失衡。
对这种情况，应该先顺时针再逆时针旋转原树并进行相应修改：对于删除操作，由于被删除结点可能位于树的内部，需要进一步考虑更多操作。
2．物理设计(1)存储结构基础结构：平衡树结点组合结构：平衡树(2)建立平衡二叉查找树实现操作的主函数为：此函数只是接收参数。
其具体实现依赖于将要提及的插入函数。
(3)插入新结点插入的主函数为：根据插入元素的大小决定插入哪株子树。
如果插入成功，如树增高，根据增长的不同程度决定是否、如何旋转。
插入的过程中会调用平衡树的调整函数。
其中旋转操作的实现函数为：分别实现对特定结点的“旋转”操作。
而要在插入过程中实现调平，还需要更进一步的函数：调平时也结合平衡因子进行判定，并采取相应行为。
针对右子树的调平大体类似。
(4)删除结点删除过程中，对于被删除的结点，如果其左右子树有一为空，则可以以另一子树的根节点替代其地位。
否则，删除后须继续考虑调平。
此处的调平有利用前面的部分函数，也有一些新的函数：删除操作的从函数。
其有二级从函数：四、测试结果输入-1后开始选择函数五、系统不足与经验体会1.没有找到更直观的显示方式，界面不够友好；2.没有输出到文件中，读取不方便。
六、附录：源代码（带注释）见附件。
#include <iostream>using namespace std;const int MAXI = 100;const int LH = 1;const int EH = 0;const int RH = -1;class BSTNode{public:BSTNode(){data = 0;bf = EH;lchild = NULL;rchild = NULL;};~BSTNode(){if(lchild != NULL){lchild->~BSTNode();}if(rchild != NULL){rchild->~BSTNode();}}int data;int bf;//Balance FactorBSTNode *lchild, *rchild;};class BSTpublic:BST(){root = NULL;taller = 0;shorter = 0;}~BST(){};BSTNode *R_Rotate(BSTNode *CurrPTR){BSTNode *TempL = NULL;TempL = CurrPTR->lchild;CurrPTR->lchild = TempL->rchild;TempL->rchild = CurrPTR;CurrPTR = TempL;return CurrPTR;}BSTNode *L_Rotate(BSTNode *CurrPTR){BSTNode *TempR = NULL;TempR = CurrPTR->rchild;CurrPTR->rchild = TempR->lchild;TempR->lchild = CurrPTR;CurrPTR = TempR;return CurrPTR;}void L_Balance(BSTNode *CurrPTR);void R_Balance(BSTNode *CurrPTR);void Establish();bool Insert(int InVal);bool Insert(BSTNode *CurrPTR, int InVal);void Search_M();bool Search_S(BSTNode *CurrPTR, int InVal);void Display_M();void Display_S(BSTNode *CurrPTR, int Height);void Delete_S_L(BSTNode *CurrPTR);void Delete_S_R(BSTNode *CurrPTR);void Delete_S(BSTNode *CurrPTR, BSTNode *NextPTR);bool Delete_M(BSTNode *CurrPTR, int DelVal);private:BSTNode *root;bool taller;bool shorter;};void Selection();int main(){cout << "Hello world!" << endl;cout << "Balanced Selection Tree of Kirov_Tujin." << endl << "main :: Orders:" << endl<< "E. Establish a Balanced Selection Tree." << endl<< "Q. Quit the program." << endl;Selection();return 0;}void Selection(){BST Tree;char Order = 0;bool Selecting = 0;while(Selecting == 0){cout << "Selection 1:Input your Order." << endl;cin >> Order;switch (Order){case 'E':{Selecting = 1;Tree.Establish();break;}case 'Q':{cout << "Selection 1:Quit?('Y' to Quit.)" << endl;cin >> Order;if(Order == 'Y'){return;}else{cout << "Selection 1:Quit:Illegal Input." << endl;}break;}default :{cout << "Selection 1:Illegal Input." << endl;}}}cout << "Selection :: Orders:" << endl<< "S. Search for a key-word." << endl<< "I. Insert a key-word into the tree." << endl<< "D. Delete a key-word from the tree." << endl<< "P. Display the tree." << endl<< "Q. Quit the program." << endl;while(Selecting){cout << "Selection 2:Input your Order." << endl;cin >> Order;switch (Order){case 'S':{cout << "Selection 2:Searching." << endl;Tree.Search_M();cout << "Selection 2:Search Finished." << endl;break;}case 'I':{cout << "Selection 2:Inserting." << endl;int InVal = 0;cout << "Input the value you want." << endl;cin >> InVal;Tree.Insert(InVal);cout << "Selection 2:Insertion Finished." << endl;break;}case 'D':{cout << "Selection 2:Deleteing." << endl;;cout << "Selection 2:Deleting Finished." << endl;break;}case 'P':{cout << "Selection 2:Displaying." << endl;Tree.Display_M();cout << "Selection 2:Display Finished." << endl;break;}case 'Q':{cout << "Selection 2:Quit?('Y' to Quit.)" << endl;cin >> Order;if(Order == 'Y'){return;}else{cout << "Selection 2:Quit:Illegal Input." << endl;}break;}default :{cout << "Selection 2:Illegal Input." << endl;}}}cout << "Selection ended." << endl;return;}void BST :: L_Balance(BSTNode *CurrPTR){BSTNode *TempL = NULL, *TempL_R = NULL;TempL = CurrPTR->lchild;switch (TempL->bf){case LH:{R_Rotate(CurrPTR);CurrPTR->bf = EH;TempL->bf = EH;break;}case RH:{TempL_R = TempL->rchild;L_Rotate(CurrPTR->lchild);R_Rotate(CurrPTR);switch(TempL_R->bf){case LH:{CurrPTR->bf = RH;TempL->bf = EH;break;}case EH:{CurrPTR->bf = EH;TempL->bf = EH;break;}case RH:{CurrPTR->bf = EH;TempL->bf = LH;break;}TempL_R->bf = EH;}}}return;}void BST :: R_Balance(BSTNode *CurrPTR){BSTNode *TempR = NULL, *TempR_L = NULL;TempR = CurrPTR->rchild;switch (TempR->bf){case LH:{R_Rotate(CurrPTR);CurrPTR->bf = EH;TempR->bf = EH;break;}case RH:{TempR_L = TempR->lchild;L_Rotate(CurrPTR->lchild);R_Rotate(CurrPTR);switch(TempR_L->bf){case LH:{CurrPTR->bf = RH;TempR->bf = EH;break;}case EH:{CurrPTR->bf = EH;TempR->bf = EH;break;}case RH:{CurrPTR->bf = EH;TempR->bf = LH;break;}}TempR_L->bf = EH;}}return;}bool BST :: Insert(BSTNode *CurrPTR, int InVal){if(CurrPTR == NULL){BSTNode CURR;CurrPTR = &CURR;CurrPTR->data = InVal;taller = true;}else{if(CurrPTR->data == InVal){taller = false;cout << "BST:Insert_S:Value Existed." << endl;return 0;}else if(CurrPTR->data < InVal){if(Insert(CurrPTR->lchild,InVal) == 0){return 0;}else if(taller){switch(CurrPTR->bf){case LH:{L_Balance(CurrPTR);taller = false;break;}case EH:{CurrPTR->bf = LH;taller = true;break;}case RH:{CurrPTR->bf = EH;taller = false;break;}}}}else if(CurrPTR->data > InVal){if(Insert(CurrPTR->rchild,InVal) == 0){return 0;}else if(taller){switch(CurrPTR->bf){case LH:{CurrPTR->bf = EH;taller = false;break;}case EH:{CurrPTR->bf = RH;taller = true;break;}case RH:{R_Balance(CurrPTR);taller = false;break;}}}}}return 1;}bool BST :: Insert(int InVal){if(root == NULL){BSTNode CURR;root = &CURR;root->data = InVal;taller = true;}else{if(root->data == InVal){taller = false;cout << "BST:Insert_S:Value Existed." << endl;return 0;}else if(root->data < InVal){if(Insert(root->lchild,InVal) == 0){return 0;}else if(taller){switch(root->bf){case LH:{L_Balance(root);taller = false;break;}case EH:{root->bf = LH;taller = true;break;}case RH:{root->bf = EH;taller = false;break;}}}}else if(root->data > InVal){if(Insert(root->rchild,InVal) == 0){return 0;}else if(taller){switch(root->bf){case LH:{root->bf = EH;taller = false;break;}case EH:{root->bf = RH;taller = true;break;}case RH:{R_Balance(root);taller = false;break;}}}}}return 1;}void BST :: Search_M(){cout << "Input the value you want." << endl;int WanaVal = 0;cin >> WanaVal;bool Found = 0;Found = Search_S(root,WanaV al);return;}bool BST :: Search_S(BSTNode *CurrPTR, int WanaVal) {if(WanaVal == CurrPTR->data){return true;}else if((WanaVal < CurrPTR->data)&&(CurrPTR->lchild != NULL)){return Search_S(CurrPTR->lchild,WanaVal);}else if((WanaVal < CurrPTR->data)&&(CurrPTR->rchild != NULL)){return Search_S(CurrPTR->rchild,WanaV al);}return false;}void BST :: Display_M(){Display_S(root,0);return;}void BST :: Display_S(BSTNode *CurrPTR, int Height) {cout << "Height:" << Height << "\tData:";if(CurrPTR == NULL){cout << '#' << endl;return;}else{cout << CurrPTR->data << endl;Display_S(CurrPTR->lchild,Height+1);Display_S(CurrPTR->rchild,Height+1);}return;}void BST :: Establish(){int InVal = 0;do{cout << "Input the value you want." << endl;cin >> InVal;Insert(root,InVal);}while(InVal != -1);return;}void BST :: Delete_S_L(BSTNode *CurrPTR){BSTNode *TempR = NULL, *TempR_L = NULL;if(CurrPTR->bf == LH){CurrPTR->bf = 0;shorter = 0;}else if(CurrPTR->bf == EH){CurrPTR->bf = RH;shorter = 0;}else{TempR = CurrPTR->rchild;if(CurrPTR->bf == EH){L_Rotate(CurrPTR);TempR->bf = 1;CurrPTR->bf = -1;shorter = 0;}else if(TempR->bf == RH){L_Rotate(CurrPTR);TempR->bf = NULL;CurrPTR->bf = 0;shorter = 1;}else{TempR_L = TempR->lchild;TempR->lchild = TempR_L->rchild;TempR_L->rchild = TempR;CurrPTR->rchild = TempR_L->lchild;TempR_L->lchild = CurrPTR;if(TempR_L->bf == EH){CurrPTR->bf = EH;TempR->bf = EH;}else if(TempR_L->bf == RH){CurrPTR->bf = LH;TempR->bf = EH;}else{CurrPTR->bf = 0;TempR->bf = LH;}TempR_L->bf = EH;CurrPTR = TempR_L;shorter = true;}}return;}void BST :: Delete_S_R(BSTNode *CurrPTR){BSTNode *TempL = NULL, *TempL_R = NULL;if(CurrPTR->bf == LH){CurrPTR->bf = 0;shorter = 0;}else if(CurrPTR->bf == EH){CurrPTR->bf = RH;shorter = 0;}else{TempL = CurrPTR->rchild;if(CurrPTR->bf == EH){L_Rotate(CurrPTR);TempL->bf = 1;CurrPTR->bf = -1;shorter = 0;}else if(TempL->bf == RH){L_Rotate(CurrPTR);TempL->bf = NULL;CurrPTR->bf = 0;shorter = 1;}else{TempL_R = TempL->lchild;TempL->lchild = TempL_R->rchild;TempL_R->rchild = TempL;CurrPTR->rchild = TempL_R->lchild;TempL_R->lchild = CurrPTR;if(TempL_R->bf == EH){CurrPTR->bf = EH;TempL->bf = EH;}else if(TempL_R->bf == RH){CurrPTR->bf = LH;TempL->bf = EH;}else{CurrPTR->bf = 0;TempL->bf = LH;}TempL_R->bf = EH;CurrPTR = TempL_R;shorter = true;}}return;}void BST :: Delete_S(BSTNode *CurrPTR, BSTNode *NextPTR) {if(NextPTR->rchild == NULL){CurrPTR->data = NextPTR->data;CurrPTR = NextPTR;NextPTR = NextPTR->lchild;delete(NextPTR);shorter = 1;}else{Delete_S(CurrPTR,NextPTR->rchild);if(shorter == LH)Delete_S_R(CurrPTR);}return;}bool BST :: Delete_M(BSTNode *CurrPTR, int DelVal){bool Deleted = false;BSTNode *DelPTR;if(CurrPTR == NULL){cout << "No such node." << endl;return false;}else if(DelVal<CurrPTR->data){Deleted = Delete_M(CurrPTR->rchild,DelVal);if(shorter == 1)R_Balance(CurrPTR,shorter);return Deleted;}else{DelPTR = CurrPTR;if(CurrPTR->rchild == NULL){CurrPTR = CurrPTR->lchild;delete DelPTR;shorter = 1;}else if(CurrPTR->lchild == NULL){CurrPTR = CurrPTR->rchild;delete DelPTR;shorter = 1;}else{Delete_S(DelPTR,DelPTR->lchild,shorter);if(shorter == 1)L_Balance(CurrPTR,shorter);CurrPTR = DelPTR;}return true;}}。