6天通吃树结构—— 第二天 平衡二叉树

最新推荐文章于 2023-05-05 20:28:09 发布
最新推荐文章于 2023-05-05 20:28:09 发布
阅读量416 收藏
点赞数 1
分类专栏： 树

原 ：

http://www.cnblogs.com/huangxincheng/archive/2012/07/22/2603956.html

 

上一篇我们聊过，二叉查找树不是严格的O(logN)，导致了在真实场景中没有用武之地，谁也不愿意有O(N)的情况发生，

作为一名码农，肯定会希望能把“范围查找”做到地球人都不能优化的地步。

     当有很多数据灌到我的树中时，我肯定会希望最好是以“完全二叉树”的形式展现，这样我才能做到“查找”是严格的O(logN)，

比如把这种”树“调正到如下结构。

     

这里就涉及到了“树节点”的旋转，也是我们今天要聊到的内容。

 

一：平衡二叉树（AVL）

1：定义

       父节点的左子树和右子树的高度之差不能大于1，也就是说不能高过1层，否则该树就失衡了，此时就要旋转节点，在

编码时，我们可以记录当前节点的高度，比如空节点是-1，叶子节点是0，非叶子节点的height往根节点递增，比如在下图

中我们认为树的高度为h=2。

 

#region 平衡二叉树节点
    /// <summary>
    /// 平衡二叉树节点
    /// </summary>
    /// <typeparam name="K"></typeparam>
    /// <typeparam name="V"></typeparam>
    public class AVLNode<K, V>
    {
        /// <summary>
        /// 节点元素
        /// </summary>
        public K key;

        /// <summary>
        /// 增加一个高度信息
        /// </summary>
        public int height;

        /// <summary>
        /// 节点中的附加值
        /// </summary>
        public HashSet<V> attach = new HashSet<V>();

        /// <summary>
        /// 左节点
        /// </summary>
        public AVLNode<K, V> left;

        /// <summary>
        /// 右节点
        /// </summary>
        public AVLNode<K, V> right;

        public AVLNode() { }

        public AVLNode(K key, V value, AVLNode<K, V> left, AVLNode<K, V> right)
        {
            //KV键值对
            this.key = key;
            this.attach.Add(value);

            this.left = left;
            this.right = right;
        }
    }
    #endregion

 

2：旋转

    节点再怎么失衡都逃不过4种情况，下面我们一一来看一下。

① 左左情况（左子树的左边节点）

我们看到，在向树中追加“节点1”的时候，根据定义我们知道这样会导致了“节点3"失衡，满足“左左情况“，可以这样想，把这

棵树比作齿轮，我们在“节点5”处把齿轮往下拉一个位置，也就变成了后面这样“平衡”的形式，如果用动画解释就最好理解了。

#region 第一种：左左旋转（单旋转）
        /// <summary>
        /// 第一种：左左旋转（单旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public AVLNode<K, V> RotateLL(AVLNode<K, V> node)
        {
            //top：需要作为顶级节点的元素
            var top = node.left;

            //先截断当前节点的左孩子
            node.left = top.right;

            //将当前节点作为temp的右孩子
            top.right = node;

            //计算当前两个节点的高度
            node.height = Math.Max(Height(node.left), Height(node.right)) + 1;
            top.height = Math.Max(Height(top.left), Height(top.right)) + 1;

            return top;
        }
        #endregion

② 右右情况（右子树的右边节点）

同样，”节点5“满足”右右情况“，其实我们也看到，这两种情况是一种镜像，当然操作方式也大同小异，我们在”节点1“的地方

将树往下拉一位，最后也就形成了我们希望的平衡效果。

#region 第二种：右右旋转（单旋转）
        /// <summary>
        /// 第二种：右右旋转（单旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public AVLNode<K, V> RotateRR(AVLNode<K, V> node)
        {
            //top：需要作为顶级节点的元素
            var top = node.right;

            //先截断当前节点的右孩子
            node.right = top.left;

            //将当前节点作为temp的右孩子
            top.left = node;

            //计算当前两个节点的高度
            node.height = Math.Max(Height(node.left), Height(node.right)) + 1;
            top.height = Math.Max(Height(top.left), Height(top.right)) + 1;

            return top;
        }
        #endregion

③左右情况（左子树的右边节点）

从图中我们可以看到，当我们插入”节点3“时，“节点5”处失衡，注意，找到”失衡点“是非常重要的，当面对”左右情况“时，我们将

失衡点的左子树进行"右右情况旋转"，然后进行”左左情况旋转“，经过这样两次的旋转就OK了，很有意思，对吧。

#region 第三种：左右旋转（双旋转）
        /// <summary>
        /// 第三种：左右旋转（双旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public AVLNode<K, V> RotateLR(AVLNode<K, V> node)
        {
            //先进行RR旋转
            node.left = RotateRR(node.left);

            //再进行LL旋转
            return RotateLL(node);
        }
        #endregion

④右左情况(右子树的左边节点）

这种情况和“情景3”也是一种镜像关系，很简单，我们找到了”节点15“是失衡点，然后我们将”节点15“的右子树进行”左左情况旋转“，

然后进行”右右情况旋转“，最终得到了我们满意的平衡。

#region 第四种：右左旋转（双旋转）
        /// <summary>
        /// 第四种：右左旋转（双旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public AVLNode<K, V> RotateRL(AVLNode<K, V> node)
        {
            //执行左左旋转
            node.right = RotateLL(node.right);

            //再执行右右旋转
            return RotateRR(node);

        }
        #endregion

3：添加

    如果我们理解了上面的这几种旋转，那么添加方法简直是轻而易举，出现了哪一种情况调用哪一种方法而已。

#region 添加操作
        /// <summary>
        /// 添加操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public AVLNode<K, V> Add(K key, V value, AVLNode<K, V> tree)
        {
            if (tree == null)
                tree = new AVLNode<K, V>(key, value, null, null);

            //左子树
            if (key.CompareTo(tree.key) < 0)
            {
                tree.left = Add(key, value, tree.left);

                //如果说相差等于2就说明这棵树需要旋转了
                if (Height(tree.left) - Height(tree.right) == 2)
                {
                    //说明此时是左左旋转
                    if (key.CompareTo(tree.left.key) < 0)
                    {
                        tree = RotateLL(tree);
                    }
                    else
                    {
                        //属于左右旋转
                        tree = RotateLR(tree);
                    }
                }
            }

            //右子树
            if (key.CompareTo(tree.key) > 0)
            {
                tree.right = Add(key, value, tree.right);

                if ((Height(tree.right) - Height(tree.left) == 2))
                {
                    //此时是右右旋转
                    if (key.CompareTo(tree.right.key) > 0)
                    {
                        tree = RotateRR(tree);
                    }
                    else
                    {
                        //属于右左旋转
                        tree = RotateRL(tree);
                    }
                }
            }

            //将value追加到附加值中（也可对应重复元素）
            if (key.CompareTo(tree.key) == 0)
                tree.attach.Add(value);

            //计算高度
            tree.height = Math.Max(Height(tree.left), Height(tree.right)) + 1;

            return tree;
        }
        #endregion

4：删除

删除方法跟添加方法也类似，当删除一个结点的时候，可能会引起祖先结点的失衡，所以在每次”结点“回退的时候计算结点高度。

#region 删除当前树中的节点
        /// <summary>
        /// 删除当前树中的节点
        /// </summary>
        /// <param name="key"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public AVLNode<K, V> Remove(K key, V value, AVLNode<K, V> tree)
        {
            if (tree == null)
                return null;

            //左子树
            if (key.CompareTo(tree.key) < 0)
            {
                tree.left = Remove(key, value, tree.left);

                //如果说相差等于2就说明这棵树需要旋转了
                if (Height(tree.left) - Height(tree.right) == 2)
                {
                    //说明此时是左左旋转
                    if (key.CompareTo(tree.left.key) < 0)
                    {
                        tree = RotateLL(tree);
                    }
                    else
                    {
                        //属于左右旋转
                        tree = RotateLR(tree);
                    }
                }
            }
            //右子树
            if (key.CompareTo(tree.key) > 0)
            {
                tree.right = Remove(key, value, tree.right);

                if ((Height(tree.right) - Height(tree.left) == 2))
                {
                    //此时是右右旋转
                    if (key.CompareTo(tree.right.key) > 0)
                    {
                        tree = RotateRR(tree);
                    }
                    else
                    {
                        //属于右左旋转
                        tree = RotateRL(tree);
                    }
                }
            }
            /*相等的情况*/
            if (key.CompareTo(tree.key) == 0)
            {
                //判断里面的HashSet是否有多值
                if (tree.attach.Count > 1)
                {
                    //实现惰性删除
                    tree.attach.Remove(value);
                }
                else
                {
                    //有两个孩子的情况
                    if (tree.left != null && tree.right != null)
                    {
                        //根据平衡二叉树的中顺遍历，需要找到”有子树“的最小节点
                        tree.key = FindMin(tree.right).key;

                        //删除右子树的指定元素
                        tree.right = Remove(tree.key, value, tree.right);
                    }
                    else
                    {
                        //自减高度
                        tree = tree.left == null ? tree.right : tree.left;

                        //如果删除的是叶子节点直接返回
                        if (tree == null)
                            return null;
                    }
                }
            }

            //统计高度
            tree.height = Math.Max(Height(tree.left), Height(tree.right)) + 1;

            return tree;
        }
        #endregion

5: 测试

不像上一篇不能在二叉树中灌有序数据，平衡二叉树就没关系了，我们的需求是检索2012-7-30 4:00:00 到 2012-7-30 5:00:00

的登陆用户的ID，数据量在500w，看看平衡二叉树是如何秒杀对手。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.IO;
using System.Diagnostics;

namespace DataStruct
{
    class Program
    {
        static void Main(string[] args)
        {
            AVLTree<int, int> avl = new AVLTree<int, int>();

            Dictionary<DateTime, int> dic = new Dictionary<DateTime, int>();

            AVLTree<DateTime, int> tree = new AVLTree<DateTime, int>();

            //500w
            for (int i = 1; i < 5000000; i++)
            {
                dic.Add(DateTime.Now.AddMinutes(i), i);

                tree.Add(DateTime.Now.AddMinutes(i), i);
            }

            //检索2012-7-30 4:00:00 到 2012-7-30 5:00:00的登陆人数
            var min = Convert.ToDateTime("2012/7/30 4:00:00");

            var max = Convert.ToDateTime("2012/7/30 5:00:00");

            var watch = Stopwatch.StartNew();

            var result1 = dic.Keys.Where(i => i >= min && i <= max).Select(i => dic[i]).ToList();

            watch.Stop();

            Console.WriteLine("字典查找耗费时间:{0}ms", watch.ElapsedMilliseconds);

            watch = Stopwatch.StartNew();

            var result2 = tree.SearchRange(min, max);

            watch.Stop();

            Console.WriteLine("平衡二叉树查找耗费时间:{0}ms", watch.ElapsedMilliseconds);
        }
    }

    #region 平衡二叉树节点
    /// <summary>
    /// 平衡二叉树节点
    /// </summary>
    /// <typeparam name="K"></typeparam>
    /// <typeparam name="V"></typeparam>
    public class AVLNode<K, V>
    {
        /// <summary>
        /// 节点元素
        /// </summary>
        public K key;

        /// <summary>
        /// 增加一个高度信息
        /// </summary>
        public int height;

        /// <summary>
        /// 节点中的附加值
        /// </summary>
        public HashSet<V> attach = new HashSet<V>();

        /// <summary>
        /// 左节点
        /// </summary>
        public AVLNode<K, V> left;

        /// <summary>
        /// 右节点
        /// </summary>
        public AVLNode<K, V> right;

        public AVLNode() { }

        public AVLNode(K key, V value, AVLNode<K, V> left, AVLNode<K, V> right)
        {
            //KV键值对
            this.key = key;
            this.attach.Add(value);

            this.left = left;
            this.right = right;
        }
    }
    #endregion

    public class AVLTree<K, V> where K : IComparable
    {
        public AVLNode<K, V> node = null;

        #region 添加操作
        /// <summary>
        /// 添加操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void Add(K key, V value)
        {
            node = Add(key, value, node);
        }
        #endregion

        #region 添加操作
        /// <summary>
        /// 添加操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public AVLNode<K, V> Add(K key, V value, AVLNode<K, V> tree)
        {
            if (tree == null)
                tree = new AVLNode<K, V>(key, value, null, null);

            //左子树
            if (key.CompareTo(tree.key) < 0)
            {
                tree.left = Add(key, value, tree.left);

                //如果说相差等于2就说明这棵树需要旋转了
                if (Height(tree.left) - Height(tree.right) == 2)
                {
                    //说明此时是左左旋转
                    if (key.CompareTo(tree.left.key) < 0)
                    {
                        tree = RotateLL(tree);
                    }
                    else
                    {
                        //属于左右旋转
                        tree = RotateLR(tree);
                    }
                }
            }

            //右子树
            if (key.CompareTo(tree.key) > 0)
            {
                tree.right = Add(key, value, tree.right);

                if ((Height(tree.right) - Height(tree.left) == 2))
                {
                    //此时是右右旋转
                    if (key.CompareTo(tree.right.key) > 0)
                    {
                        tree = RotateRR(tree);
                    }
                    else
                    {
                        //属于右左旋转
                        tree = RotateRL(tree);
                    }
                }
            }

            //将value追加到附加值中（也可对应重复元素）
            if (key.CompareTo(tree.key) == 0)
                tree.attach.Add(value);

            //计算高度
            tree.height = Math.Max(Height(tree.left), Height(tree.right)) + 1;

            return tree;
        }
        #endregion

        #region 计算当前节点的高度
        /// <summary>
        /// 计算当前节点的高度
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public int Height(AVLNode<K, V> node)
        {
            return node == null ? -1 : node.height;
        }
        #endregion

        #region 第一种：左左旋转（单旋转）
        /// <summary>
        /// 第一种：左左旋转（单旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public AVLNode<K, V> RotateLL(AVLNode<K, V> node)
        {
            //top：需要作为顶级节点的元素
            var top = node.left;

            //先截断当前节点的左孩子
            node.left = top.right;

            //将当前节点作为temp的右孩子
            top.right = node;

            //计算当前两个节点的高度
            node.height = Math.Max(Height(node.left), Height(node.right)) + 1;
            top.height = Math.Max(Height(top.left), Height(top.right)) + 1;

            return top;
        }
        #endregion

        #region 第二种：右右旋转（单旋转）
        /// <summary>
        /// 第二种：右右旋转（单旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public AVLNode<K, V> RotateRR(AVLNode<K, V> node)
        {
            //top：需要作为顶级节点的元素
            var top = node.right;

            //先截断当前节点的右孩子
            node.right = top.left;

            //将当前节点作为temp的右孩子
            top.left = node;

            //计算当前两个节点的高度
            node.height = Math.Max(Height(node.left), Height(node.right)) + 1;
            top.height = Math.Max(Height(top.left), Height(top.right)) + 1;

            return top;
        }
        #endregion

        #region 第三种：左右旋转（双旋转）
        /// <summary>
        /// 第三种：左右旋转（双旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public AVLNode<K, V> RotateLR(AVLNode<K, V> node)
        {
            //先进行RR旋转
            node.left = RotateRR(node.left);

            //再进行LL旋转
            return RotateLL(node);
        }
        #endregion

        #region 第四种：右左旋转（双旋转）
        /// <summary>
        /// 第四种：右左旋转（双旋转）
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public AVLNode<K, V> RotateRL(AVLNode<K, V> node)
        {
            //执行左左旋转
            node.right = RotateLL(node.right);

            //再执行右右旋转
            return RotateRR(node);

        }
        #endregion

        #region 是否包含指定元素
        /// <summary>
        /// 是否包含指定元素
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Contain(K key)
        {
            return Contain(key, node);
        }
        #endregion

        #region 是否包含指定元素
        /// <summary>
        /// 是否包含指定元素
        /// </summary>
        /// <param name="key"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public bool Contain(K key, AVLNode<K, V> tree)
        {
            if (tree == null)
                return false;
            //左子树
            if (key.CompareTo(tree.key) < 0)
                return Contain(key, tree.left);

            //右子树
            if (key.CompareTo(tree.key) > 0)
                return Contain(key, tree.right);

            return true;
        }
        #endregion

        #region 树的指定范围查找
        /// <summary>
        /// 树的指定范围查找
        /// </summary>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <returns></returns>
        public HashSet<V> SearchRange(K min, K max)
        {
            HashSet<V> hashSet = new HashSet<V>();

            hashSet = SearchRange(min, max, hashSet, node);

            return hashSet;
        }
        #endregion

        #region 树的指定范围查找
        /// <summary>
        /// 树的指定范围查找
        /// </summary>
        /// <param name="range1"></param>
        /// <param name="range2"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public HashSet<V> SearchRange(K min, K max, HashSet<V> hashSet, AVLNode<K, V> tree)
        {
            if (tree == null)
                return hashSet;

            //遍历左子树（寻找下界）
            if (min.CompareTo(tree.key) < 0)
                SearchRange(min, max, hashSet, tree.left);

            //当前节点是否在选定范围内
            if (min.CompareTo(tree.key) <= 0 && max.CompareTo(tree.key) >= 0)
            {
                //等于这种情况
                foreach (var item in tree.attach)
                    hashSet.Add(item);
            }

            //遍历右子树（两种情况：①:找min的下限 ②：必须在Max范围之内）
            if (min.CompareTo(tree.key) > 0 || max.CompareTo(tree.key) > 0)
                SearchRange(min, max, hashSet, tree.right);

            return hashSet;
        }
        #endregion

        #region 找到当前树的最小节点
        /// <summary>
        /// 找到当前树的最小节点
        /// </summary>
        /// <returns></returns>
        public AVLNode<K, V> FindMin()
        {
            return FindMin(node);
        }
        #endregion

        #region 找到当前树的最小节点
        /// <summary>
        /// 找到当前树的最小节点
        /// </summary>
        /// <param name="tree"></param>
        /// <returns></returns>
        public AVLNode<K, V> FindMin(AVLNode<K, V> tree)
        {
            if (tree == null)
                return null;

            if (tree.left == null)
                return tree;

            return FindMin(tree.left);
        }
        #endregion

        #region 找到当前树的最大节点
        /// <summary>
        /// 找到当前树的最大节点
        /// </summary>
        /// <returns></returns>
        public AVLNode<K, V> FindMax()
        {
            return FindMin(node);
        }
        #endregion

        #region 找到当前树的最大节点
        /// <summary>
        /// 找到当前树的最大节点
        /// </summary>
        /// <param name="tree"></param>
        /// <returns></returns>
        public AVLNode<K, V> FindMax(AVLNode<K, V> tree)
        {
            if (tree == null)
                return null;

            if (tree.right == null)
                return tree;

            return FindMax(tree.right);
        }
        #endregion

        #region 删除当前树中的节点
        /// <summary>
        /// 删除当前树中的节点
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public void Remove(K key, V value)
        {
            node = Remove(key, value, node);
        }
        #endregion

        #region 删除当前树中的节点
        /// <summary>
        /// 删除当前树中的节点
        /// </summary>
        /// <param name="key"></param>
        /// <param name="tree"></param>
        /// <returns></returns>
        public AVLNode<K, V> Remove(K key, V value, AVLNode<K, V> tree)
        {
            if (tree == null)
                return null;

            //左子树
            if (key.CompareTo(tree.key) < 0)
            {
                tree.left = Remove(key, value, tree.left);

                //如果说相差等于2就说明这棵树需要旋转了
                if (Height(tree.left) - Height(tree.right) == 2)
                {
                    //说明此时是左左旋转
                    if (key.CompareTo(tree.left.key) < 0)
                    {
                        tree = RotateLL(tree);
                    }
                    else
                    {
                        //属于左右旋转
                        tree = RotateLR(tree);
                    }
                }
            }
            //右子树
            if (key.CompareTo(tree.key) > 0)
            {
                tree.right = Remove(key, value, tree.right);

                if ((Height(tree.right) - Height(tree.left) == 2))
                {
                    //此时是右右旋转
                    if (key.CompareTo(tree.right.key) > 0)
                    {
                        tree = RotateRR(tree);
                    }
                    else
                    {
                        //属于右左旋转
                        tree = RotateRL(tree);
                    }
                }
            }
            /*相等的情况*/
            if (key.CompareTo(tree.key) == 0)
            {
                //判断里面的HashSet是否有多值
                if (tree.attach.Count > 1)
                {
                    //实现惰性删除
                    tree.attach.Remove(value);
                }
                else
                {
                    //有两个孩子的情况
                    if (tree.left != null && tree.right != null)
                    {
                        //根据平衡二叉树的中顺遍历，需要找到”有子树“的最小节点
                        tree.key = FindMin(tree.right).key;

                        //删除右子树的指定元素
                        tree.right = Remove(tree.key, value, tree.right);
                    }
                    else
                    {
                        //自减高度
                        tree = tree.left == null ? tree.right : tree.left;

                        //如果删除的是叶子节点直接返回
                        if (tree == null)
                            return null;
                    }
                }
            }

            //统计高度
            tree.height = Math.Max(Height(tree.left), Height(tree.right)) + 1;

            return tree;
        }
        #endregion
    }
}

wow,相差98倍，这个可不是一个级别啊...AVL神器。

 

猫小呆
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
广工数据结构实验——平衡二叉树
07-06
广工数据结构实验——平衡二叉树 里面含有：源代码、可执行程序、说明文档
平衡二叉树（AVL）平衡化旋转详解
sunnyoldboy博客
10-09 3871
平衡二叉树的全称是平衡二叉排序树，也称为AVL树，这是因为该树结构是由Adelson-Velskii和Landis在1963年提出的。AVL树是BST树的改进结构，使得平均查找长度得到了减少，进而提高了查找的效率。
平衡二叉树的旋转
weixin_43710268的博客
10-28 4198
平衡二叉树的旋转都是发生在最小不平衡子树上的，先看一下最简单的最小不平衡子树的形态： 其中结点C的插入导致了平衡树出现了不平衡，那怎么解决更好呢，我有一个想法，那就是把这3个结点中的中位数提到根结点。那我们先来找到中位数，因为平衡二叉树是一颗排序树，对于这4种形态的树，中位数都在固定的位置： 那么我们现在来利用简化版的左旋右旋操作将中位数提到根节点： 通过这里可以大致明白旋转的操作的意义了： 左旋B：即将父亲结点A当做自己的左孩子 右旋B：即将父亲结点A当做自己的右孩子 下面看一下复杂一点的最小
平衡二叉树旋转机制
最新发布
qq_52146944的博客
05-05 1159
左旋是将一个节点的右子节点旋转到它的位置上，同时将该节点移到其左侧，并重新连接其子节点。右旋是将一个节点的左子节点旋转到它的位置上，同时将该节点移到其右侧，并重新连接其子节点。平衡二叉树的旋转机制是一种通过对树进行旋转操作来保持其平衡的方法。平衡二叉树的旋转机制包括两种基本类型的旋转：左旋和右旋，以及它们的组合。
平衡二叉树的实现原理
热门推荐
吴小宝的博客
08-18 1万+
1.概念 平衡二叉树建立在二叉排序树的基础上，目的是使二叉排序树的平均查找长度更小，即让各结点的深度尽可能小，因此，树中每个结点的两棵子树的深度不要偏差太大。 平衡二叉树的递归定义：平衡二叉树是一棵二叉树，其可以为空，或满足如下2个性质：①左右子树深度之差的绝对值不大于1。②左右子树都是平衡二叉树。 平衡因子的概念：结点的平衡因子 = 结点的左子树深度 — 结点的右子树深度。 最低不平衡结
广工数据结构课程设计——平衡二叉树操作的演示
07-06
广工数据结构课程设计——平衡二叉树操作的演示 内含源代码、可执行程序以及相应的说明文档 实验的功能包括： [实现提示] (1) 初始，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。每种操作均要...
数据结构作业：第6章二叉树作业.docx
12-16
数据结构作业：第6章二叉树作业.docx
数据结构作业：第6章二叉树作业答案.docx
12-13
数据结构作业：第6章二叉树作业答案.docx
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过...
实现平衡二叉树(AVL树)的旋转
qq_64431576的博客
09-21 1278
平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为 AVL 树， 可以保证查询效率较高。
【平衡二叉搜索树（AVL）-- 旋转】
m0_熊猫馆主的博客
05-01 1277
打怪升级：第60天旋转是为了在保持平衡树性质的前提下降低树的高度，右子树高AVLTree，也就是我们所说的：自平衡二叉搜索树，AVL命名由来是两位发明者的名字的首字母，并无其他含义。AVL树是一棵搜索树；AVL树左右子树的高度差的绝对值不大于1；AVL树的左右子树也是AVL树。高度差可取0,1,-1。注：我们将左右子树的高度差称为平衡因子，简称为bf既然AVL树是一棵搜索树它就需要满足搜索树的特征：左子树不空，左子树上的值都小于根节点的值；右子树不空，右子树上的值都大于根节点的值；左右子树也都是二叉搜索树。
平衡二叉树旋转详解
Hyacinth_Dy
04-29 1万+
平衡二叉树的定义（AVL）定义 平衡二叉树或者是一棵空树，或者满足以下的性质：它的左子树和右子树的高度之差的绝对值不超过1，并且左子树和右子树也是一个平衡二叉树。 平衡因子 左子树高度减去右子树的高度的值或者右子树高度减去左子树高度的值。显然 -1 <=bf <= 1 AVL树的引入 平衡二叉树在二叉排序树上引入的，在二叉树中，如果插入的节点接近有序，那么二叉树就会退化为链表大大降低了查找效率
浅析平衡二叉树的四种旋转
IT夜幕的博客
03-09 6411
浅析平衡二叉树（AVL树）的四种旋转 平衡二叉树中每个节点的左子树和右子树高度之差的绝对值小于等于1 在二叉树插入数据后会有四种类型，为了符合平衡二叉树左孩子与右孩子高度只差绝对值小于等于1，那么就会形成四种旋转变形，以达到平衡。 一.LL型 如图所示，插入数据10,8,5,根据二叉树插入数据规则，因为8小于10，那8就在10的左边，然后插入数据5,5小于10，5又小于8,5就在8的左边，就会形成LL型。此时不符合平衡二叉树定义，为了达到左右孩子平衡，需要进行旋转。10经过一次右旋，结果左右孩子平衡。
平衡二叉树的旋转以及简便方法
hello_program_world的博客
04-06 4814
刚开始听这个平衡二叉树的旋转，一听就蒙了，后来看了很多视频，有很多的说法。下面来介绍平衡二叉树 平衡二叉树：就是每个节点的平衡因子(Balance Factor)(以下简称BF)的绝对值小于等于1，即为0或1。 而BF就是每个节点左子树的高度减去右子树的高度。 平衡二叉树的旋转共有四种情况： 下面说一个定义，新插入的节点为破坏点，而由于破坏点的存在使二叉树失衡(|BF|>1)的节点为被破坏节点 　　　　1.LL型：即为被破坏节点的左子树的左子树插入破坏节点。如图： 数值为...
平衡二叉树的旋转_平衡二叉树的旋转
weixin_39614228的博客
12-06 226
一、平衡二叉树的定义为避免树的高度增长过快，降低二叉树的排序性能，规定在插入和删除二叉树结点时，保证任意结点的左右子树高度差的绝对值不大于1。这样的二叉树被称为平衡二叉树(Balanced Binary Tree)。二、平衡因子平衡因子：结点的平衡因子 = 结点的左子树深度 —结点的右子树深度。若平衡因子的取值为-1、0或1时，该节点是平衡的，否则是不平衡的。最低不平衡...
【数据结构】详解平衡二叉树AVL旋转操作(附相关C++代码)
weixin_50941083的博客
05-16 1404
本文介绍了什么是平衡二叉树，并详解了它的旋转操作。
平衡二叉树（树的旋转）
蓝天的博客
10-15 2137
1.概念 平衡二叉树建立在二叉排序树的基础上，目的是使二叉排序树的平均查找长度更小，即让各结点的深度尽可能小，因此，树中每个结点的两棵子树的深度不要偏差太大。 平衡二叉树的递归定义：平衡二叉树是一棵二叉树，其可以为空，或满足如下2个性质：①左右子树深度之差的绝对值不大于1。②左右子树都是平衡二叉树。 平衡因子的概念：结点的平衡因子 = 结点的左子树深度 — 结点的右子树深度。若平衡因子的取值为-1、0或1时，该节点是平衡的，否则是不平衡的。 最低不平衡结点的概念：用A表示最低不平衡结点，则A的祖先结点可能有
详细剖析平衡二叉树的四种旋转（附C++代码）
jyx1572676601的博客
02-10 3750
经过一天的学习，笔者发现网上少有人剖析平衡二叉树为何要分为四种旋转情况(尤其是LR型和RL型旋转)，学习起来感觉云里雾里。查阅相关资料后，笔者整理了以下几种解释，其中夹杂着笔者自己的理解(笔者也是初学，水平不足，如有缺漏错误的地方，望读者指出)。 一.单向右旋(RR)和左旋(LL) 1. 这个很好理解，可以把节点3的位置看作一个定滑轮(支点)，滑轮左边的绳子较长，无法平衡，那么就把1-2-3绳子往右拉，则节点2就被拉到了支点处，左右两边绳子长度相等，重量均匀，则保持平衡。看下面一种情况： .
Java算法与数据结构测试——二叉树
04-06
1. 什么是二叉树？ 二叉树是一种树形结构，其中每个节点最多有两个子节点。一个节点的左子节点比该节点小，右子节点比该节点大。二叉树通常用于搜索和排序。 2. 二叉树的遍历方法有哪些？ 二叉树的遍历方法包括前序遍历、中序遍历和后序遍历。前序遍历是从根节点开始遍历，先访问根节点，再访问左子树，最后访问右子树。中序遍历是从根节点开始遍历，先访问左子树，再访问根节点，最后访问右子树。后序遍历是从根节点开始遍历，先访问左子树，再访问右子树，最后访问根节点。 3. 二叉树的查找方法有哪些？ 二叉树的查找方法包括递归查找和非递归查找。递归查找是从根节点开始查找，如果当前节点的值等于要查找的值，则返回当前节点。如果要查找的值比当前节点小，则继续在左子树中查找；如果要查找的值比当前节点大，则继续在右子树中查找。非递归查找可以使用栈或队列实现，从根节点开始，每次将当前节点的左右子节点入栈/队列，直到找到要查找的值或者栈/队列为空。 4. 二叉树的插入与删除操作如何实现？ 二叉树的插入操作是将要插入的节点与当前节点的值进行比较，如果小于当前节点的值，则继续在左子树中插入；如果大于当前节点的值，则继续在右子树中插入。当找到一个空节点时，就将要插入的节点作为该空节点的子节点。删除操作需要分为三种情况：删除叶子节点、删除只有一个子节点的节点和删除有两个子节点的节点。删除叶子节点很简单，只需要将其父节点的对应子节点置为空即可。删除只有一个子节点的节点，需要将其子节点替换为该节点的位置。删除有两个子节点的节点，则可以找到该节点的后继节点（即右子树中最小的节点），将其替换为该节点，然后删除后继节点。 5. 什么是平衡二叉树？ 平衡二叉树是一种特殊的二叉树，它保证左右子树的高度差不超过1。这种平衡可以确保二叉树的查找、插入和删除操作的时间复杂度都是O(logn)。常见的平衡二叉树包括红黑树和AVL树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值