C++入门教程（13）平衡二叉树

已于 2022-03-19 13:23:52 修改
阅读量2.2k 收藏 5
点赞数 2
分类专栏： C++
于 2022-03-14 16:12:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011416077/article/details/123479435
版权

b树 数据结构 算法

说来惭愧，数据结构学了10年了，直到今天才弄明白这个平衡二叉树的代码实现（之前只是知道原理，现在也可以自己造轮子用C++实现了）。

平衡二叉树其实就是二叉树，它是二叉树的一种特殊结构，主要是为了提高查找效率

假如有1023个节点，那么最多只需要10次就能找到目标节点。

转换成平衡二叉树的左旋和右旋的实现，其实就是为了使树平衡，将这棵树做最少的改动。并且前提条件是插入节点之前，这颗树是平衡的，所以只有4种情况会导致树的不平衡

1）依次插入3，2，1 需要右旋

2）依次插入1，2，3  需要左旋

3）依次插入1，3，2 需要先右旋再左旋

4）依次插入3，1，2 需要先左旋再右旋

以上4种情况都会导致根节点的不平衡，经过旋转以后，最终都会得到一颗以2为根节点的平衡的二叉树



#include <iostream>
using namespace std;
 
 
//树上的节点 我们只用一个value来存值 可以自行扩展存储其他数据
class TreeNode {
public:
    int _value;
    int _balance;   //平衡因子 0表示左右平衡 左边深度减右边的深度
    TreeNode *_lc;
    TreeNode *_rc;
    TreeNode()
    {
        _value = 0;
        _lc = NULL;
        _rc = NULL;
    }
};
 
//平衡二叉树
class AVLTree {
public:
 
    //每棵树都有一个根节点
    TreeNode * _root;
    
 
    //向一个树中插入一个元素
    TreeNode* insertValue(TreeNode * &node,int value)
    {
        if (node == NULL)
        {
            //如果节点为空,直接创建一个节点
            node = new TreeNode();
            node->_value = value;
            node->_balance = 0;
            
        }
        //如果当前插入的值比根节点大
        else if (value > node->_value )
        {
            //如果有右子树 , 往右子树里面插入
            node->_rc = insertValue(node->_rc, value);
            if(getTreeDepth(node->_rc)-getTreeDepth(node->_lc)==2)//插入后失衡
            {
                
                if( value > node->_rc->_value )
                {
                    //       N                         NR
                    //         \                     /    \
                    //          NR            =>    N      NRR
                    //           \
                    //            NRR
                    node = LeftRotate(node);
                }
                else
                {
                    //       N                    N                         NRL
                    //         \                    \                      /  \
                    //          NR        =>         NRL        =>       N     NR
                    //          /                       \
                    //         NRL
                    node = RightLeftRotate(node);
                }
            }
            
            
        }
        //如果有左子树 , 往左子树里面插入
        else
        {
            
            node->_lc = insertValue(node->_lc, value);
            
            if(getTreeDepth(node->_lc)-getTreeDepth(node->_rc)==2)//插入后失衡
            {
                if( value > node->_lc->_value )
                {
                    //       N                        N                  NLR
                    //      /                       /                   /  \
                    //    NL            =>        NLR           =>    NL    N
                    //      \                    /
                    //      NLR                 NL
                    
                    node=LeftRightRotate(node);//左右的旋转
                    
                }
                else
                {
                    
                    //       N                        NL
                    //      /                        /    \
                    //    NL            =>        NLL      N
                    //    /
                    //  NLL
                    node=RightRotate(node);//右旋
                }
            }
            
        }
            
            
        //更新节点的高度
        _root->_balance = getTreeDepth(_root->_lc ) - getTreeDepth(_root->_rc );
    
        return node;
    }
    
    
    //右旋一棵二叉树
    TreeNode * RightRotate(TreeNode *&node)
    {
        int balanceFactor = getTreeDepth(node->_lc) - getTreeDepth(node->_rc);
        if (balanceFactor != 2)
        {
            cout << "不符合右旋条件" << endl;
            return node;
        }
        
        //旋转前 二叉树是平衡的
        
        //       N                        NL
        //      /                        /    \
        //    NL            =>        NLL      N
        //    /
        //  NLL
        
        
        //         N                            NL
        //       /   \                     /        \
        //      NL     NR            =>   NLL        N
        //    /  \                          \       / \
        //   NLL  NLR                       NLLR   NLR NR
        //     \
        //      NLLR
        
        
        
        TreeNode *NL = node->_lc;
        node->_lc = NL->_rc;
        NL->_rc = node;
        return NL;
    }

    
    
    
    
    //左旋一棵二叉树
    TreeNode * LeftRotate(TreeNode *&node)
    {
        int balanceFactor = getTreeDepth(node->_lc) - getTreeDepth(node->_rc);
        if (balanceFactor != -2)
        {
            cout << "不符合左旋条件" << endl;
            return node;
        }
        
        //       N                         NR
        //         \                     /    \
        //          NR            =>    N      NRR
        //           \
        //            NRR
        
        //         N                            NR
        //       /   \                     /        \
        //      NL     NR            =>   N        NRR
        //             / \               /  \         \
        //           NRL   NRR          NL   NRL        NRRR
        //                  \
        //                  NRRR
        
        TreeNode *NR = node->_rc;
        node->_rc = NR->_lc;
        NR->_lc = node;
        return NR;
    }
    
    
    //先右旋再左旋
    TreeNode * RightLeftRotate(TreeNode *&node)
    {
        
        //       N                    N                         NRL
        //         \                    \                      /  \
        //          NR        =>         NRL        =>       N     NR
        //          /                       \
        //         NRL                      NR
        
        RightRotate(node->_rc);
        return LeftRotate(node);
        
    }
    
    //先右旋再左旋
    TreeNode * LeftRightRotate(TreeNode *&node)
    {
        
        //       N                        N                  NLR
        //      /                       /                   /  \
        //    NL            =>        NLR           =>    NL    N
        //      \                    /
        //      NLR                 NL
        
        LeftRotate(node->_lc);
        return RightRotate(node);
        
    }
    
    
    
    //获取二叉树的深度（左右子树的最大深度+1）
    int getTreeDepth(TreeNode * root)
    {
         if (root == NULL)
         {
             return 0;
         }
        
         int leftTreeDepth = getTreeDepth(root->_lc);
         int rightTreeDepth = getTreeDepth(root->_rc);
         return leftTreeDepth > rightTreeDepth ? leftTreeDepth + 1 : rightTreeDepth + 1;

    }
    

    //获取最大节点(一直向右边找节点)
    TreeNode * getMaxNode(TreeNode * root)
    {
         if (root!= NULL )
         {
              if (root->_rc != NULL)
              {
                  return getMaxNode(root->_rc);

              }
              else
              {
                  return root;
              }
         }
        else
        {
            return NULL;
        }
    }

    //获取最小节点(一直向左边找节点)
    TreeNode * getMinNode(TreeNode * root)
    {
        if (root!= NULL )
        {
             if (root->_lc != NULL)
             {
                 return getMinNode(root->_lc);

             }
             else
             {
                 return root;
             }
        }
       else
       {
           return NULL;
       }
    }


    //中序遍历
    void printTreeMid(TreeNode * root)
    {
        if (root!= NULL) {
            printTreeMid(root->_lc);
            std::cout << root->_value << "," ;
            printTreeMid(root->_rc);
        }
    }


    //前序遍历
    void printTreeFront(TreeNode * root)
    {
        if (root != NULL) {
            std::cout << root->_value << "," ;
            printTreeFront(root->_lc);
            printTreeFront(root->_rc);
        }
    }

    //后序遍历
    void printTreeBack(TreeNode * root)
    {
        if (root != NULL) {
            printTreeBack(root->_lc);
            printTreeBack(root->_rc);
            std::cout << root->_value << "," ;
        }
    }
};
 
void testFun(TreeNode * node)
{
    
}


int main()
{
    // 创建一个平衡二叉树
    AVLTree * avlTree = new AVLTree();
    for (int i = 1 ; i < 1024 ; i++)
    {
        avlTree->insertValue(avlTree->_root, i);
    }
    
    cout << "树的深度为 ：" << avlTree->getTreeDepth(avlTree->_root) <<endl;
    
    avlTree->printTreeFront(avlTree->_root);
    
    cout<<endl;
}

运行：

树的深度为 ：10

可以看到树的深度为10，如果按照上一节的插入操作不做平衡处理的话，这棵树的深度达到最坏的情况1023，也就会导致1023这个节点在查找的时候会找1023次才能找到

特殊的：当平衡二叉树是一颗满二叉树的时候，根节点刚好是最中间的那个值

爱我呦呦
关注
专栏目录
二叉平衡树（C++）
wo_ai_luo_的博客
02-25 1062
平衡二叉树也叫做AVL树,AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树(Self-Balancing Binary Search Tree,简称平衡二叉树。我们怎么知道这棵二叉搜索树平不平衡呢？我们知道，二叉搜索树的搜索时间和高度是有直接关系的，但是我们按递增、递减序输入之后，高度就和n一样了，所以时间复杂度为O(log n).想要优化，就是改变这棵二叉搜索树的高度。
平衡二叉树（c++）
photoresist的博客
03-10 777
平衡二叉树定义平衡二叉树类二叉树的调整右单旋左单旋左右双旋插入删除操作完整代码 定义 平衡树(Balance Tree，BT) 指的是，任意节点的子树的高度差都小于等于1。常见的符合平衡树的有，B树（多路平衡搜索树）、AVL树（二叉平衡搜索树）等。平衡树可以完成集合的一系列操作, 时间复杂度和空间复杂度相对于“2-3树”要低，在完成集合的一系列操作中始终保持平衡，为大型数据库的组织、索引提供了一条新的途径 平衡二叉树类 继承二叉树类 二叉树类代码（GitHub）：https://github.com/r
平衡二叉树（纯C++实现）
03-04
包含AVL树的创建，删除，查找等等功能，我使用的是VS2010的编译器，可能用版本低的编译器无法打开
C++实现平衡二叉树
Jinyao的博客
12-28 900
1.概念 平衡二叉树(AVL Tree)首先要满足二叉树的定义,如下 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若右子树不空，则右子树上所有结点的值均大于它的根结点的值； 左、右子树也分别为二叉排序树； 没有键值相等的节点。 平衡度是左子树高度减去右子树高度，平衡度只能是-1,+1,0 ...
C++：平衡搜索二叉树（AVL）
最新发布
2301_80153885的博客
07-27 1024
int _bf;:_kv(kv),_bf(0){}由于要保证左右子树高度之差的绝对值不超过1(-1/0/1)，所以引用了平衡因子_bf来维护，平衡因子的计算为右子树高度减去左子树高度因为AVL树会对节点进行旋转，所以引入了父节点指针_parent来维护。
平衡二叉树c++实现
09-26
AVL的c++非递归实现 经测试可直接使用 由于在网上找的程序均有些小bug（可以用此程序中的测试代码测试，较少有别的代码能直接通过），所以自己写了一个。
c++算法入门学习
02-15
在数据结构方面，C++提供了数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、哈希表等基础结构。每个数据结构都有其特定的应用场景，比如栈常用于递归和后进先出（LIFO）操作，队列用于先进先出（FIFO）...
C++ 简单的英汉词典
05-16
尽管在提供的代码片段中并未明确使用平衡二叉树，但为了提高词典查询效率，可以考虑使用平衡二叉树（例如AVL树或红黑树）来组织词典数据。平衡二叉树是一种自平衡的二叉查找树，可以在O(log n)的时间复杂度内完成...
平衡二叉树图书管理系统
12-01
tree.insert(Book(1003, 'C++入门', '王五', '机械工业出版社', 49.99)) tree.insert(Book(1004, '数据结构与算法', '赵六', '电子工业出版社', 59.99)) tree.traverse() tree.save_to_file('books.dat') tree....
2021优秀C++教程大全【入门至提高】【初赛&复赛】【建议收藏】
Andysun06的博客
08-09 683
零、初赛相关 基础知识题库 一、语言基础 指针和结构体 关于指针的那些事 二、算法基础 快速排序 图解快速排序 三、数据结构 树 树的简介及二叉排序树C++模板实现. 关于二叉查找树的一些事儿（bst详解，平衡树入门） 树的简介及二叉排序树C++模板实现. 史上最强图解Treap总结， 不是浅谈！ 无旋Treap——FHQ-Treap详解 FHQ-Treap学习笔记 浅析Treap——平衡树 栈 栈的简介及C++模板实现 ←总结（更加具体）
真c++ 从二叉树到红黑树（6）之红黑树RedBlack
天翔龙闪
05-23 859
此文章为从二叉树到红黑树系列文章的第六节，主要介绍介绍红黑树，相信，有了之前BST，AVL和B树的铺垫，你会很快地理解红黑树。
数据结构 - 平衡二叉树（C++）
热门推荐
了解➔熟悉➔掌握➔精通
02-22 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 平衡二叉树的定义 平衡二叉树（Balanced Binary Tree）是具有以下性质的二叉树：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 判断一棵二叉树是否平衡（C++） /* * Cr...
C++平衡二叉树（AVL）
深海一诺
04-18 700
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质:它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 当二叉树不平衡时，可以通过左单旋，右单旋，左右双旋，右左双旋的方式将它调整平衡； 如图： #include<iostream> using namespace std; templ
平衡二叉树（C++实现）
qq_39559641的博客
11-04 8478
二叉树实现插入、查询、删除功能
平衡二叉树的判断（哈哈哈哈自己写的，cool，先写一次的条件，不直接返回true再直接返回往下的）
weixin_44895315的博客
07-26 130
给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：true 示例 2： 输入：root = [1,2,2,3,3,null,null,4,4] 输出：false 示例 3： 输入：root = [] 输出：true 提示： 树中的节点数在范围 [0, 5000] 内 -104 <= Node.val <= 1
平衡二叉树（C++）
Jerry_Leo_liu的博客
04-03 335
题目： 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 思路： 当左右子树分别为平衡二叉树，且左右子树的深度差小于等于1时，该二叉树平衡 因此可以使用递归思想去判断子树的平衡性，再判断左右子树的深度差是否满足平衡条件 代码实现： class Solution { public: bool IsBalanced_Solution(TreeNode* pRoot) { ...
平衡二叉树（C/C++）
Ivan_47的博客
12-28 408
描述： 平衡二叉树是二叉搜索树的改进，本文基于你已了解二叉搜索树为前提，不了解的朋友请看这里： https://blog.csdn.net/Ivan_47/article/details/111831396 当我们使用二叉搜索树时，若我们按递增或递减的顺序插入结点，那么每一次的新结点都会插入在左子树或右子树，这样一来二叉树便退化为了链表，那么搜索的效率就会降低。 为提升二叉排序树的平均效率，可将其升级为平衡二叉树，其特点是：所有根结点的左子树和右子树深度差不超过1。其中左右子树的深度差也称为平衡因子。每插入
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱我呦呦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值