北邮数据结构平衡二叉树报告概论
北邮数据结构实验报告
北邮数据结构实验报告北京邮电大学信息与通信工程学院2009级数据结构实验报告实验名称：实验三哈夫曼编/解码器的实现学生姓名：陈聪捷日期：2010年11月28日1.实验要求一、实验目的：了解哈夫曼树的思想和相关概念;二、实验内容：利用二叉树结构实现哈夫曼编/解码器1.初始化：能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立哈夫曼树。
2.建立编码表：利用已经建好的哈夫曼树进行编码，并将每个字符的编码输出。
3.编码：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
4.译码：利用已经建好的哈夫曼树对编码后的字符串进行译码，并输出译码结果。
5.打印：以直观的方式打印哈夫曼树。
6.计算输入的字符串编码前和编码后的长度，并进行分析，讨论哈夫曼编码的压缩效果。
7.用户界面可以设计成“菜单”方式，能进行交互，根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。
2.程序分析2.1存储结构二叉树templateclassBiTree{public:BiTree();//构造函数，其前序序列由键盘输入~BiTree(void);//析构函数BiNode*Getroot();//获得指向根结点的指针protected:BiNode*root;//指向根结点的头指针};//声明类BiTree及定义结构BiNodeData：二叉树是由一个根结点和两棵互不相交的左右子树构成data:HCode*HCodeTable;//编码表inttSize;//编码表中的总字符数二叉树的节点结构templatestructBiNode//二叉树的结点结构{Tdata;//记录数据Tlchild;//左孩子Trchild;//右孩子Tparent;//双亲};编码表的节点结构structHCode{chardata;//编码表中的字符charcode[100];//该字符对应的编码};待编码字符串由键盘输入，输入时用链表存储，链表节点为structNode{charcharacter;//输入的字符unsignedintcount;//该字符的权值boolused;//建立树的时候该字符是否使用过Node*next;//保存下一个节点的地址};示意图：2.2关键算法分析1.初始化函数(voidHuffmanTree::Init(stringInput))算法伪代码：1.初始化链表的头结点2.获得输入字符串的第一个字符，并将其插入到链表尾部,n=1(n 记录的是链表中字符的个数)3.从字符串第2个字符开始，逐个取出字符串中的字符3.1将当前取出的字符与链表中已经存在的字符逐个比较，如果当前取出的字符与链表中已经存在的某个字符相同，则链表中该字符的权值加1。
数据结构中平衡二叉树的定义
数据结构中平衡二叉树的定义平衡二叉树？哎呦，这个名字一听就让人有点晕，搞得我差点以为是个什么高深的数学公式，其实不然，它就是一种数据结构。
你想象一下，平衡二叉树就像一个超级讲究的家庭，每个人都必须保持“平衡”，不然就容易乱套。
这个家庭的成员，或者说是“节点”，总共有两个子节点，而且它们的“家务活”分配要特别均匀，不能有一个子节点忙得像打了鸡血，另一个却轻松得像度假。
说白了，平衡二叉树就是告诉你，“兄弟姐妹”们得公平分工，不能让某个“孩子”走得太远，另一个就被落下。
我们得弄清楚什么是“二叉树”。
嘿，其实二叉树就是每个节点最多只能有两个子节点的树形结构，简单点说，就是每个人最多只能有两个“孩子”，并且这两个“孩子”得排排坐，不能一个高一个矮，那样看起来就不和谐了。
可要是左边的“孩子”特别高，右边的又短得跟个小矮人一样，那也不行，得保持两边差不多高。
嘿，听起来像什么？就像家里有两个孩子，一个高得过头，一个低得不行，结果谁都不开心。
平衡二叉树特别讲究左右子树的“差距”。
差距得控制在一定范围内，通常说是不能超过1。
就是说，如果左边的子树高出了1层，右边的子树就不能高出2层。
否则呢，这个二叉树就不平衡了，像你站在一只跛脚的板凳上，随时可能摔倒。
再简单点说，平衡二叉树就像我们家常见的“八仙过海，各显神通”，每个节点都有各自的位置和作用，位置偏离太多就得重新调整调整，确保大家的体力和位置保持均衡。
有的朋友可能会问，既然这么讲究“平衡”，那它怎么判断自己是否平衡呢？嘿，这里就要用到一个神奇的“高度差”了。
我们通常用每个节点的左右子树的高度差来判断。
如果某个节点的左右子树的高度差超过了1，说明它就失去平衡了。
那么我们该怎么办呢？就像你掉进了泥潭，要不是用力蹬两下，要不就是找人来拉一把，二叉树也是一样，得“旋转”一下才能恢复平衡。
平衡二叉树一旦出现不平衡，就得做旋转操作。
别想歪了，旋转不是让树开个舞会，而是指用一种特别的方式重新安排节点的位置。
北邮数据结构平衡二叉树报告概论
数据结构实验报告实验名称：平衡二叉树1.实验目的和内容根据平衡二叉树的抽象数据类型的定义，使用二叉链表实现一个平衡二叉树。
二叉树的基本功能：1、平衡二叉树的建立2、平衡二叉树的查找3、平衡二叉树的插入4、平衡二叉树的删除5、平衡二叉树的销毁6、其他：自定义操作编写测试main()函数测试平衡二叉树的正确性。
2. 程序分析2.1 存储结构struct node{int key; //值int height; //这个结点的父节点在这枝最长路径上的结点个数node *left; //左孩子指针node *right; //右孩子指针node(int k){ key = k; left = right = 0; height = 1; } //构造函数};2.2 程序流程2.3 关键算法分析（由于函数过多，在此只挑选部分重要函数）算法1：void AVL_Tree::left_rotate(node *&x)[1] 算法功能：对 R-R型进行调整[2] 算法基本思想：将结点右孩子进行逆时针旋转[3] 算法空间、时间复杂度分析：都为0（1）[4] 代码逻辑node *y = x->right; y为x的右孩子x->right = y->left; 将y的左孩子赋给x的右孩子 y->left = x; x变为y的左孩子fixheight(x); 修正x，y的height值fixheight(y);x = y; 使x的父节点指向y 算法2：void A VL_Tree::right_rotate(node *&x)[1] 算法功能：对L-L型进行调整[2] 算法基本思想：将左孩子进行顺时针旋转[3] 算法空间、时间复杂度分析：都为0（1）[4] 代码逻辑node *y = x->left; //y为x的左孩子 x->left = y->right; y的右孩子赋给x的左孩子y->right = x; x变为y的右孩子fixheight(x); 修正x和y的height值fixheight(y);x = y; 使x的父节点指向y算法3：node*& A VL_Tree::balance(node *&p)[1] 算法功能：对给定结点进行平衡操作[2] 算法基本思想：通过平衡因子判断属于哪种情况，再依照情况进行平衡[3] 算法空间、时间复杂度分析：没有递归和循环，都为O（1）[4] 代码逻辑fixheight(p); //修正P的height值if (bfactor(p) == 2) 平衡因子为2，为L-？型if (bfactor(p->left) < 0) P的左孩子平衡因子<0时，为L-R型，执行left_rotate(p->left); 相关平衡操作，若>0，为L-L型。
数据结构程序的设计报告(平衡二叉树)
数学与计算机科学学院数据结构程序设计报告平衡二叉树学生姓名:学号:班级:指导老师:报告日期:1.题目与要求1). 问题的提出编写已个平衡二叉树，主要是对插入一个元素导致树不平衡的情况进行平衡化处理以及相关的处理。
2）设计的知识点队列的插入，删除，二叉树的建立于销毁，平衡树的平衡化，以及C语言中基础应用于结构等。
3）功能要求(1).通过不断插入的方式创建一棵平衡二叉树，包括输入结点的关键字和相关信息。
(2)按要求输出创建的平衡二叉树结点，包括顺序（中序）输出和按层次输出。
(3)插入新增的结点，若结点不存在则插入平衡二叉树，并进行相关调整。
(4)销毁二叉树。
(5)退出菜单界面如下：2.功能设计算法设计选择创建平衡二叉树后，利用循环不断插入结点，并进行调整，当输入节点为0时停止进入菜单界面。
在平横二叉树排序树BSTree上插入一个新的数据元素ｅ的递归算法可如下描述：（１）若BSTree为空树，则插入一个数据元素为e的新结点作为BSTree的根结点，树的深度增1；（２）若e的关键字和BSTree的根节点的关键字相等，则不进行插入；（３）若e的关键字小于BSTree的根结点的关键字，而且在其左子树中不存在和e形同的关键字的结点，则将e插入在其左子树上，并且当插入之后的左子树的深度加1时，分别就下列不同情况处理之：a.BSTree的跟结点的平衡因子为-1（右子树的深度大于左子树的深度）：则将跟结点的平衡因子更改为0，BBST的深度不变；b.BBST的根结点的平衡因子为0（左，右子树的深度相等）：则将根结点的平衡因子更改为1，BBST的深度增1；c.BBST的根结点的平衡因子为1（左子树的深度大于右子树的深度）：若BBST的左子树根结点的平衡因子为1，则需进行向左旋平衡处理，并且在右旋之后，将根节点和其右子树根节点的平衡因子更改为0，树的深度不变；若BBST的左子树根结点的平衡因子为-1，则需进行向左，向右的双向旋转平衡处理，并且在旋转处理之后，修改根结点和其左右子树的平衡因子，数的深度不变；（４）若e的关键字大于BBST的根结点的关键字，而且在BBST的右子树中不存在和e有相同的关键字的的节点，则将e插入在BBST的右子树上，并且当插入之后的右子树深度增加（+1）时，分别就不同情况处理之。
平衡二叉树的实现及分析
平衡二叉树的实现及分析平衡二叉树（Balanced Binary Tree），也称为AVL树，是一种自平衡二叉查找树。
它的每个节点都包含一个额外的平衡因子，即左子树的高度减去右子树的高度，取值为-1、0或1、通过维护这个平衡因子，AVL树可以在查找、插入和删除操作中自动保持平衡，从而保证了较高的性能。
AVL树的实现基于二叉查找树（Binary Search Tree），它的插入和删除操作与二叉查找树相同。
然而，当进行插入或删除操作后，AVL树需要通过旋转操作保持平衡，这是AVL树与普通二叉查找树的主要区别。
AVL树的平衡性保证了树的高度不超过O(log n)，这使得查找、插入和删除的平均时间复杂度都为O(log n)。
具体而言，当插入或删除操作导致树不再平衡时，需要进行以下四种旋转操作之一来恢复平衡：1. 左旋（Left Rotation）：以当前节点为支点，将其右子节点变为新的根节点，并将原根节点作为新根节点的左子节点。
2. 右旋（Right Rotation）：以当前节点为支点，将其左子节点变为新的根节点，并将原根节点作为新根节点的右子节点。
3. 左右旋（Left-Right Rotation）：先对当前节点的左子节点进行左旋操作，然后再对当前节点进行右旋操作。
4. 右左旋（Right-Left Rotation）：先对当前节点的右子节点进行右旋操作，然后再对当前节点进行左旋操作。
具体的实现中，需要对每个节点保存其高度信息。
在进行插入和删除操作时，先按照二叉查找树的规则进行操作，并更新节点的高度信息。
然后，逐级向上检查每个节点的平衡因子，如果平衡因子不在[-1,0,1]的范围内，就进行相应的旋转操作。
完成旋转后，需要更新相关节点的高度信息。
AVL树的平衡性能保证了在最坏情况下的时间复杂度为O(log n)，不过由于维护平衡需要进行旋转操作，相对于普通的二叉查找树，AVL树的插入和删除操作可能会较慢一些。
实验报告平衡二叉树
实习报告一、需求分析1、问题描述利用平衡二叉树实现一个动态查找表。
（1）实现动态查找表的三种基本功能：查找、插入和删除。
（2）初始时，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。
每种操作均要提示输入关键字。
在查找时，如果查找的关键字不存在，则把其插入到平衡二叉树中。
每次插入或删除一个结点后，应更新平衡二叉树的显示。
（3）每次操作的关键字都要从文件中读取，并且关键字的集合限定为短整型数字{1，2，3······}，关键字出现的顺序没有限制，允许出现重复的关键字，并对其进行相应的提示。
（4）平衡二叉树的显示采用图形界面画出图形。
2、系统功能打开数据文件，用文件中的关键字来演示平衡二叉树操作的过程。
3、程序中执行的命令包括：（1）(L)oad from data file //在平衡的二叉树中插入关键字；（2）(A)ppend new record //在平衡的二叉树中查找关键字；（3）(U)pate special record //显示调整过的平衡二叉树；（4）(D)elete special record //删除平衡二叉树中的关键字；（5）(Q)uit //结束。
4、测试数据：平衡二叉树为：图 1 插入关键字10之前的平衡二叉树插入关键字：10；调整后：图 2 插入关键字10之后的平衡二叉树删除关键字：14；调整后：图 3 删除关键字14后的平衡二叉树查找关键字：11；输出：The data is here!图 3 查找关键字11后的平衡二叉树二、概要设计本次实验目的是为了实现动态查找表的三种基本功能：查找、插入和删除。
动态查找表可有不同的表示方法，在此次实验中主要是以平衡二叉树的结构来表示实现的，所以需要两个抽象数据类型：动态查找表和二叉树。
1、动态查找表的抽象数据类型定义为：ADT DynamicSearchTable{数据对象D ：D是具有相同特性的数据元素的集合。
数据结构二叉树实验报告
数据结构二叉树实验报告二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。
本文将介绍二叉树的定义、基本操作以及一些常见的应用场景。
一、二叉树的定义和基本操作二叉树是一种特殊的树形结构，它的每个节点最多有两个子节点。
一个节点的左子节点称为左子树，右子节点称为右子树。
二叉树的示意图如下：```A/ \B C/ \D E```在二叉树中，每个节点可以有零个、一个或两个子节点。
如果一个节点没有子节点，我们称之为叶子节点。
在上面的示例中，节点 D 和 E 是叶子节点。
二叉树的基本操作包括插入节点、删除节点、查找节点和遍历节点。
插入节点操作可以将一个新节点插入到二叉树中的合适位置。
删除节点操作可以将一个指定的节点从二叉树中删除。
查找节点操作可以在二叉树中查找指定的节点。
遍历节点操作可以按照一定的顺序遍历二叉树中的所有节点。
二、二叉树的应用场景二叉树在计算机科学中有着广泛的应用。
下面将介绍一些常见的应用场景。
1. 二叉搜索树二叉搜索树是一种特殊的二叉树，它的每个节点的值都大于其左子树中的节点的值，小于其右子树中的节点的值。
二叉搜索树可以用来实现快速的查找、插入和删除操作。
它在数据库索引、字典等场景中有着重要的应用。
2. 堆堆是一种特殊的二叉树，它的每个节点的值都大于或小于其子节点的值。
堆可以用来实现优先队列，它在任务调度、操作系统中的内存管理等场景中有着重要的应用。
3. 表达式树表达式树是一种用来表示数学表达式的二叉树。
在表达式树中，每个节点可以是操作符或操作数。
表达式树可以用来实现数学表达式的计算，它在编译器、计算器等场景中有着重要的应用。
4. 平衡二叉树平衡二叉树是一种特殊的二叉树，它的左子树和右子树的高度差不超过1。
平衡二叉树可以用来实现高效的查找、插入和删除操作。
它在数据库索引、自平衡搜索树等场景中有着重要的应用。
三、总结二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。
本文介绍了二叉树的定义、基本操作以及一些常见的应用场景。
北京邮电大学 数据结构 实验二 二叉树 可视化设计
数据结构实验报告实验名称：实验2——二叉树的构造学生姓名：XXXXNB班级：XXXXXX班内序号：学号：XXXXXXX日期：XXXXXXXX1．实验要求根据二叉树的抽象数据类型的定义，使用二叉链表实现一个二叉树。
二叉树的基本功能：1、二叉树的建立2、前序遍历二叉树3、中序遍历二叉树4、后序遍历二叉树5、按层序遍历二叉树6、求二叉树的深度7、求指定结点到根的路径8、二叉树的销毁9、其他：自定义操作编写测试main()函数测试线性表的正确性2.程序分析2.1 存储结构采用二叉树的存储结构，其中每个二叉树的结点定义了一个结构体，该结构体包含三个元素，分别是一个T 类型的数据域data，一个指向T 类型的指针左孩子，一个指向T 类型的指针右孩子，示意图如图所示：2.2 关键算法分析代码描述：1.构造函数template < class T >void BiTree<T>::Creat(BiNode<T>*&R, T data[], int i,int n)//i表示位置，从1开始，n表示数组长度{if (i <= n&&data[i - 1]){R = new BiNode < T > ;//创建根节点R->data = data[i - 1];Creat(R->LChild, data, 2 * i, n);//创建左子树Creat(R->RChild, data, 2 * i + 1, n);//创建右子树}else R = NULL;}template<class T>BiTree<T>::BiTree(T data[], int n){Creat(Root, data, 1, n);//利用递归循环构造}2.前序遍历//前序遍历，递归template<class T>void BiTree<T>::PreOrder(BiNode<T>*R)//前序遍历,递归//R都是源自于一开始构造所产生的根节点//根->左->右{if (R != NULL){cout << R->data<<" ";//访问结点PreOrder(R->LChild);//遍历左子树PreOrder(R->RChild);//遍历右子树}}//前序遍历，非递归template<class T>void BiTree<T>::PreOrderNormal(BiNode<T>*R)//用栈模板进行非递归操作{stack<BiNode<T>*> s;//结构栈BiNode<T>* p = R;//从根结点开始循环while (p != NULL || !s.empty()){while (p != NULL){cout << p->data << " ";s.push(p);p = p->LChild;//先压栈，再更改指针域}if (!s.empty())//检验栈是否为空,栈为空后，遍历结束{p = s.top();s.pop();p = p->RChild;}}}3.中序遍历//中序遍历，递归template<class T>void BiTree<T>::InOrder(BiNode<T>*R)//左->根->右//递归，中序遍历{if (R != NULL){InOrder(R->LChild);//遍历左子树cout << R->data<<" ";//访问节点InOrder(R->RChild);//遍历右子树}}4.后序遍历//后序遍历，递归template<class T>void BiTree<T>::PostOrder(BiNode<T>*R)//递归,后序遍历//左->右->根{if (R != NULL){PostOrder(R->LChild);//遍历左子树PostOrder(R->RChild);//遍历右子树cout << R->data<<" ";//访问节点}}时间复杂度：O（n)5.层序遍历template<class T>void BiTree<T>::LevelOrder(BiNode<T>*R)//层序遍历{queue<BiNode<T>*> q;BiNode<T>* p = R;//从根结点开始循环if(p!=NULL) q.push(p);while (!q.empty()){p = q.front();cout << p->data<<" ";q.pop();if (p->LChild != NULL) q.push(p->LChild);if (p->RChild != NULL) q.push(p->RChild);}}6.析构函数//析构函数template<class T>void BiTree<T>::Release(BiNode<T>*R){if (R != NULL){Release(R->LChild);//释放左子树Release(R->RChild);//释放右子树delete R;//释放根节点}}template<class T>BiTree<T>::~BiTree(){Release(Root);//释放二叉树}7.求二叉树深度template<class T>int BiTree<T>::Depth(BiNode<T>*R)//输出二叉树的深度{if (R == NULL) return 0;else{int m = Depth(R->LChild);int n = Depth(R->RChild);return m >= n ? m + 1:n + 1;}}时间复杂度：O（n)8.求路径template<class T>bool BiTree<T>::Findpath(BiNode<T>*R, T s)//找出指定元素到根节点的路径{if (R == NULL){return false;}else{if (R->data == s)//当前元素等于e，输出该节点{cout << R->data<<" ";return true;}else if (Findpath(R->LChild, s))//经过该结点的左孩子能到达e，输出该结点{cout << R->data<<" ";return true;}else if (Findpath(R->RChild, s))//经过该结点的右孩子能到达e,输出该结点{cout << R->data << " ";return true;}elsereturn false;}}template<class T>void BiTree<T>::Detect(BiNode<T>*R, T s){if (!(Findpath(R, s))){throw"输入元素有误！";}}3. 程序运行结果主函数流程图：测试截图：初始化二叉树，菜单创建执行功能：4. 总结.调试时出现了一些问题如：异常抛出的处理，书中并未很好的提及异常处理，通过查阅资料，选择用try catch 函数对解决。
数据结构实验报告——树
2008级数据结构实验报告实验名称：实验三树学生姓名：班级：班内序号：学号：日期：2009年11月23日1．实验要求a. 实验目的通过选择两个题目之一进行实现，掌握如下内容：掌握二叉树基本操作的实现方法了解赫夫曼树的思想和相关概念学习使用二叉树解决实际问题的能力b. 实验内容利用二叉树结构实现赫夫曼编/解码器。
基本要求：1、初始化(Init)：能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立赫夫曼树2、建立编码表(CreateTable)：利用已经建好的赫夫曼树进行编码，并将每个字符的编码输出。
3、编码(Encoding)：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
4、译码(Decoding)：利用已经建好的赫夫曼树对编码后的字符串进行译码，并输出译码结果。
5、打印(Print)：以直观的方式打印赫夫曼树（选作）6、计算输入的字符串编码前和编码后的长度，并进行分析，讨论赫夫曼编码的压缩效果。
2. 程序分析2.1 存储结构存储结构:二叉树示意图如下:2.2 关键算法分析核心算法思想：1.哈夫曼编码(Huffman Coding)是可变字长编码。
编码时借助哈夫曼树，也即带权路径长度最小的二叉树，来建立编码。
2.哈夫曼编码可以实现无损数据压缩。
单个字符用一个特定长度的位序列替代：在字符串中出现频率高的符号，使用短的位序列，而那些很少出现的符号，则用较长的位序列。
关键算法思想描述和实现：关键算法1：统计字符出现的频度，记录出现的字符及其权值，对未出现的字符不予统计编码。
将统计的叶子节点编制成数组。
为创建哈夫曼树作准备。
C++实现：for(int i=0;str[i]!='\0';i++) //统计频度frequency[(short)str[i]]++;此处以一个一维的下标表示ascII编码，以元素之表示字符频度，解决统计字符的问题。
for(int j=0;j<128;j++) //统计叶子节点个数if(frequency[j]!=0) leaf++;此处扫描一遍上面建立的数组得到叶子节点的个数，则由(leaf*2-1)得到总的节点个数。
数据结构二叉树实验报告
数据结构二叉树实验报告1. 引言二叉树是一种常见的数据结构，由节点（Node）和链接（Link）构成。
每个节点最多有两个子节点，分别称为左子节点和右子节点。
二叉树在计算机科学中被广泛应用，例如在搜索算法中，二叉树可以用来快速查找和插入数据。
本实验旨在通过编写二叉树的基本操作来深入理解二叉树的特性和实现方式。
2. 实验内容2.1 二叉树的定义二叉树可以用以下方式定义：class TreeNode:def__init__(self, val):self.val = valself.left =Noneself.right =None每个节点包含一个值和两个指针，分别指向左子节点和右子节点。
根据需求，可以为节点添加其他属性。
2.2 二叉树的基本操作本实验主要涉及以下二叉树的基本操作：•创建二叉树：根据给定的节点值构建二叉树。
•遍历二叉树：将二叉树的节点按照特定顺序访问。
•查找节点：在二叉树中查找特定值的节点。
•插入节点：向二叉树中插入新节点。
•删除节点：从二叉树中删除特定值的节点。
以上操作将在下面章节详细讨论。
3. 实验步骤3.1 创建二叉树二叉树可以通过递归的方式构建。
以创建一个简单的二叉树为例：def create_binary_tree():root = TreeNode(1)root.left = TreeNode(2)root.right = TreeNode(3)root.left.left = TreeNode(4)root.left.right = TreeNode(5)return root以上代码创建了一个二叉树，根节点的值为1，左子节点值为2，右子节点值为3，左子节点的左子节点值为4，左子节点的右子节点值为5。
3.2 遍历二叉树二叉树的遍历方式有多种，包括前序遍历、中序遍历和后序遍历。
以下是三种遍历方式的代码实现：•前序遍历：def preorder_traversal(root):if root:print(root.val)preorder_traversal(root.left)preorder_traversal(root.right)•中序遍历：def inorder_traversal(root):if root:inorder_traversal(root.left)print(root.val)inorder_traversal(root.right)•后序遍历：def postorder_traversal(root):if root:postorder_traversal(root.left)postorder_traversal(root.right)print(root.val)3.3 查找节点在二叉树中查找特定值的节点可以使用递归的方式实现。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构
实
验
报
告
实验名称：平衡二叉树
1.实验目的和内容
根据平衡二叉树的抽象数据类型的定义，使用二叉链表实现一个平衡二叉树。
二叉树的基本功能：
1、平衡二叉树的建立
2、平衡二叉树的查找
3、平衡二叉树的插入
4、平衡二叉树的删除
5、平衡二叉树的销毁
6、其他：自定义操作
编写测试main()函数测试平衡二叉树的正确性。
2. 程序分析
2.1 存储结构
struct node
{
int key; //值
int height; //这个结点的父节点在这枝最长路径上的结点个数
node *left; //左孩子指针
node *right; //右孩子指针
node(int k){ key = k; left = right = 0; height = 1; } //构造函数};
2.2 程序流程
2.3 关键算法分析（由于函数过多，在此只挑选部分重要函数）
算法1：void AVL_Tree::left_rotate(node *&x)
[1] 算法功能：对 R-R型进行调整
[2] 算法基本思想：将结点右孩子进行逆时针旋转
[3] 算法空间、时间复杂度分析：都为0（1）
[4] 代码逻辑
node *y = x->right; y为x的右孩子
x->right = y->left; 将y的左孩子赋给x的右孩子 y->left = x; x变为y的左孩子
fixheight(x); 修正x，y的height值
fixheight(y);
x = y; 使x的父节点指向y 算法2：void A VL_Tree::right_rotate(node *&x)
[1] 算法功能：对L-L型进行调整
[2] 算法基本思想：将左孩子进行顺时针旋转
[3] 算法空间、时间复杂度分析：都为0（1）
[4] 代码逻辑
node *y = x->left; //y为x的左孩子 x->left = y->right; y的右孩子赋给x的左孩子
y->right = x; x变为y的右孩子
fixheight(x); 修正x和y的height值
fixheight(y);
x = y; 使x的父节点指向y
算法3：node*& A VL_Tree::balance(node *&p)
[1] 算法功能：对给定结点进行平衡操作
[2] 算法基本思想：通过平衡因子判断属于哪种情况，再依照情况进行平衡
[3] 算法空间、时间复杂度分析：没有递归和循环，都为O（1）
[4] 代码逻辑
fixheight(p); //修正P的height值
if (bfactor(p) == 2) 平衡因子为2，为L-？型
if (bfactor(p->left) < 0) P的左孩子平衡因子<0时，为L-R型，执行left_rotate(p->left); 相关平衡操作，若>0，为L-L型。
right_rotate(p);
}
else if (bfactor(p) == -2) 平衡因子为2 ，为R-?型
{
if (bfactor(p->right)>0) P的右孩子平衡因子>0，为R-L型
right_rotate(p->right); 小于0时，为R-R型
left_rotate(p);
}
fixheight(p); 修正平衡后的P的height值
return p;
算法4：node* A VL_Tree::remove(node *&p, int k)
[1] 算法功能：删除给定key值的结点
[2] 算法基本思想：首先通过递归找到待删除结点，如果其没有右孩子，直接将其
删除，将其左孩子链上去。
若有右孩子，找到右枝中的最小结点代替待删除结
点，对改变后的结点进行平衡。
注意右孩子要删除其中的最小结点
[3] 算法空间、时间复杂度分析：有递归，递归次数最多为深度，时间复杂度0
（nlogn），空间复杂度0（logn）
[4] 代码逻辑
if (k < p->key) K小于根节点，在左枝中寻找p->left=remove(p->left, k); 递归
else if (k>p->key) K大于根节点，在右枝中寻找p->right=remove(p->right, k); 递归
else 找到待删除结点
{
node *q = p->left; q为删除结点的左孩子
node *r = p->right; p为删除结点右孩子
delete p;
if (!r) //没有右子树
return q; 直接将左孩子返回，相当于直接删除p node* min = findmin(r); //有右子树时，找到右枝中的最小值
min->right=removein(r); 使删除最小值后的右枝变为min的右枝
min->left = q; p的左孩子变为min的左孩子，相当于删除了p，
balance(min); 对min进行balance操作
return min;
}
balance(p); 每次递归完都对p进行平衡操作
return p;
算法5：void A VL_Tree::insert(node *&p, int k)
[1] 算法功能：一边插入结点一边进行平衡
[2] 算法基本思想：按照构建排序二叉树的方法插入结点，每插入一次后判断是否
需要平衡
[3] 算法空间、时间复杂度分析：插入节点寻找位置需要递归，时间复杂度O（logn）
空间复杂度O(logn)
[4] 代码逻辑
if (!p) 如果是插入第一个节点
p = new node(k); 直接构造一个结点
else if (k < p->key) 插入值小于根节点，在左枝中寻找
{
insert(p->left, k);
if (height(p->left) - height(p->right) == 2) p的平衡因子为2
{
if (k<p->left->key)
right_rotate(p); //LL型
else
left_right_rotate(p); //L-R型
}
}
else if (k>p->key) 寻找值大于根节点，在右枝中寻找{
insert(p->right, k);
if (height(p->left) - height(p->right) == -2) 平衡因子为-2
{
if (k > p->right->key)
left_rotate(p); R-R型
else
right_left_rotate(p); R-L型
}
}
else;
fixheight(p); 修正P的height值
算法6：node* A VL_Tree::findvalue(int key)
[1] 算法功能：查找key的位置
[2] 算法基本思想：根据排序二叉树的规则进项查找
[3] 算法空间时间复杂度分析：没有递归，时间复杂度0(logn)，空间复杂度O（1）
[4] 代码逻辑
node *r = root; 初始化r为根节点，进行移动查找
while (r != NULL)
{
if (key < r->key) 小于根节点，在左枝中寻找
r = r->left;
else if (key>r->key) 大于根节点，在后枝中寻找
r = r->right;
else return r;
}
throw "无此值";
2.4 其他
使用了结构类型和类的知识。
使用了STL中的算法，直接调用其寻找两个值中最小值的函数min，大大节约了时间
3.程序运行结果分析
程序运行没有问题。
编写了主函数进行了测试，测试结果正确
4.总结
4.1实验的难点和关键点
本实验的难点和关键点在于大量的递归函数以及删除结点这两个方面，递归函数一定要注意递归返回的值，而删除结点时一定要注意是属于哪种情况。
4.2心得体会
本次实验让我对递归函数有了更加深刻的理解，递归函数的难点在于递归返回，我们一定要深刻的理解递归。
递归可以使代码变得异常简洁，但是也可能带来一些问题，在编写递归的时候一定要仔细思考，注意返回值与跳出。
相信以后的编程我可以做的更好。