平衡树（AVL）详解

最新推荐文章于 2024-05-05 10:47:02 发布
最新推荐文章于 2024-05-05 10:47:02 发布
阅读量1.9k 收藏
点赞数
分类专栏： 算法与数据结构

1. 为什么平衡树？

在二叉搜索树（BST，Binary Search Tree）中提到，BST树可能会退化成一个链表（整棵树中只有左子树，或者只有右子树），这将大大影响二叉树的性能。

前苏联科学家G.M. Adelson-Velskii 和 E.M. Landis给出了答案。他们在1962年发表的一篇名为《An algorithm for the organization of information》的文章中提出了一种自平衡二叉查找树（self-balancing binary search tree）。这种二叉查找树在插入和删除操作中，可以通过一系列的旋转操作来保持平衡，从而保证了二叉查找树的查找效率。最终这种二叉查找树以他们的名字命名为“AVL-Tree”，它也被称为平衡二叉树（Balanced Binary Tree）。

2. 原理

在节点上设置一个平衡因子BF，代表左右子树的高度差，BF = { -1, 0, 1}。

3. 旋转

AVL的Insert/Delete操作可能会引起树的失衡，可以通过选择解决这个问题。

3.1 4种旋转

（1）LL

（2）RR

（3）LR

（4）RL

在下面的文章中有一个关于AVL选择的动画，大家不妨看看。

C#与数据结构--树论--平衡二叉树(AVL Tree)

3.2 旋转实现

在算法导论中给出旋转的伪代码：

[cpp] view plain copy print ?
  1. LEFT-ROTATE(T, x)  
  2.  1  y ← right[x]            ▹ Set y.  
  3.  2  right[x] ← left[y]      ▹ Turn y's left subtree into x's right subtree.  
  4.  3  p[left[y]] ← x  
  5.  4  p[y] ← p[x]             ▹ Link x's parent to y.  
  6.  5  if p[x] = nil[T]  
  7.  6     then root[T] ← y  
  8.  7     else if x = left[p[x]]  
  9.  8             then left[p[x]] ← y  
  10.  9             else right[p[x]] ← y  
  11. 10  left[y] ← x             ▹ Put x on y's left.  
  12. 11  p[x] ← y  
LEFT-ROTATE(T, x)
 1  y ← right[x]            ▹ Set y.
 2  right[x] ← left[y]      ▹ Turn y's left subtree into x's right subtree.
 3  p[left[y]] ← x
 4  p[y] ← p[x]             ▹ Link x's parent to y.
 5  if p[x] = nil[T]
 6     then root[T] ← y
 7     else if x = left[p[x]]
 8             then left[p[x]] ← y
 9             else right[p[x]] ← y
10  left[y] ← x             ▹ Put x on y's left.
11  p[x] ← y


[csharp] view plain copy print ?
  1. //旋转以root为根的子树，当高度改变，则返回true；高度未变则返回false  
  2.         private bool RotateSubTree(int bf)   
  3.         {  
  4.             bool tallChange = true;  
  5.             Node root = path[p], newRoot = null;  
  6.             if (bf == 2) //当平衡因子为2时需要进行旋转操作  
  7.             {  
  8.                 int leftBF = root.Left.BF;  
  9.                 if (leftBF == -1) //LR型旋转  
  10.                 {  
  11.                     newRoot = LR(root);  
  12.                 }  
  13.                 else if (leftBF == 1)  
  14.                 {  
  15.                     newRoot = LL(root); //LL型旋转  
  16.                 }  
  17.                 else //当旋转根左孩子的bf为0时，只有删除时才会出现  
  18.                 {  
  19.                     newRoot = LL(root);  
  20.                     tallChange = false;  
  21.                 }  
  22.             }  
  23.             if (bf == -2) //当平衡因子为-2时需要进行旋转操作  
  24.             {  
  25.                 int rightBF = root.Right.BF; //获取旋转根右孩子的平衡因子  
  26.                 if (rightBF == 1)   
  27.                 {  
  28.                     newRoot = RL(root); //RL型旋转  
  29.                 }  
  30.                 else if (rightBF == -1)  
  31.                 {  
  32.                     newRoot = RR(root); //RR型旋转  
  33.                 }  
  34.                 else //当旋转根左孩子的bf为0时，只有删除时才会出现  
  35.                 {  
  36.                     newRoot = RR(root);  
  37.                     tallChange = false;  
  38.                 }  
  39.             }  
  40.             //更改新的子树根   
  41.             if (p > 0)  
  42.             {  
  43.                 if (root.Data < path[p - 1].Data)  
  44.                 {  
  45.                     path[p - 1].Left = newRoot;  
  46.                 }  
  47.                 else  
  48.                 {  
  49.                     path[p - 1].Right = newRoot;  
  50.                 }  
  51.             }  
  52.             else  
  53.             {  
  54.                 _head = newRoot; //如果旋转根为AVL树的根，则指定新AVL树根结点  
  55.             }  
  56.             return tallChange;  
  57.         }  
  58.         //root为旋转根，rootPrev为旋转根双亲结点   
  59.         private Node LL(Node root) //LL型旋转，返回旋转后的新子树根  
  60.         {  
  61.             Node rootNext = root.Left;  
  62.             root.Left = rootNext.Right;  
  63.             rootNext.Right = root;  
  64.             if (rootNext.BF == 1)  
  65.             {  
  66.                 root.BF = 0;  
  67.                 rootNext.BF = 0;  
  68.             }  
  69.             else //rootNext.BF==0的情况，删除时用  
  70.             {  
  71.                 root.BF = 1;  
  72.                 rootNext.BF = -1;  
  73.             }  
  74.             return rootNext; //rootNext为新子树的根  
  75.         }  
  76.         private Node LR(Node root) //LR型旋转，返回旋转后的新子树根  
  77.         {  
  78.             Node rootNext = root.Left;  
  79.             Node newRoot = rootNext.Right;  
  80.             root.Left = newRoot.Right;  
  81.             rootNext.Right = newRoot.Left;  
  82.             newRoot.Left = rootNext;  
  83.             newRoot.Right = root;  
  84.             switch (newRoot.BF) //改变平衡因子  
  85.             {  
  86.                 case 0:  
  87.                     root.BF = 0;  
  88.                     rootNext.BF = 0;  
  89.                     break;  
  90.                 case 1:  
  91.                     root.BF = -1;  
  92.                     rootNext.BF = 0;  
  93.                     break;  
  94.                 case -1:  
  95.                     root.BF = 0;  
  96.                     rootNext.BF = 1;  
  97.                     break;  
  98.             }  
  99.             newRoot.BF = 0;  
  100.             return newRoot; //newRoot为新子树的根  
  101.         }  
  102.         private Node RR(Node root) //RR型旋转，返回旋转后的新子树根  
  103.         {  
  104.             Node rootNext = root.Right;  
  105.             root.Right = rootNext.Left;  
  106.             rootNext.Left = root;  
  107.             if (rootNext.BF == -1)  
  108.             {  
  109.                 root.BF = 0;  
  110.                 rootNext.BF = 0;  
  111.             }  
  112.             else //rootNext.BF==0的情况，删除时用  
  113.             {  
  114.                 root.BF = -1;  
  115.                 rootNext.BF = 1;  
  116.             }  
  117.             return rootNext; //rootNext为新子树的根  
  118.         }  
  119.         private Node RL(Node root) //RL型旋转，返回旋转后的新子树根  
  120.         {  
  121.             Node rootNext = root.Right;  
  122.             Node newRoot = rootNext.Left;  
  123.             root.Right = newRoot.Left;  
  124.             rootNext.Left = newRoot.Right;  
  125.             newRoot.Right = rootNext;  
  126.             newRoot.Left = root;  
  127.             switch (newRoot.BF) //改变平衡因子  
  128.             {  
  129.                 case 0:  
  130.                     root.BF = 0;  
  131.                     rootNext.BF = 0;  
  132.                     break;  
  133.                 case 1:  
  134.                     root.BF = 0;  
  135.                     rootNext.BF = -1;  
  136.                     break;  
  137.                 case -1:  
  138.                     root.BF = 1;  
  139.                     rootNext.BF = 0;  
  140.                     break;  
  141.             }  
  142.             newRoot.BF = 0;  
  143.             return newRoot; //newRoot为新子树的根  
  144.         }  
//旋转以root为根的子树，当高度改变，则返回true；高度未变则返回false
        private bool RotateSubTree(int bf) 
        {
            bool tallChange = true;
            Node root = path[p], newRoot = null;
            if (bf == 2) //当平衡因子为2时需要进行旋转操作
            {
                int leftBF = root.Left.BF;
                if (leftBF == -1) //LR型旋转
                {
                    newRoot = LR(root);
                }
                else if (leftBF == 1)
                {
                    newRoot = LL(root); //LL型旋转
                }
                else //当旋转根左孩子的bf为0时，只有删除时才会出现
                {
                    newRoot = LL(root);
                    tallChange = false;
                }
            }
            if (bf == -2) //当平衡因子为-2时需要进行旋转操作
            {
                int rightBF = root.Right.BF; //获取旋转根右孩子的平衡因子
                if (rightBF == 1) 
                {
                    newRoot = RL(root); //RL型旋转
                }
                else if (rightBF == -1)
                {
                    newRoot = RR(root); //RR型旋转
                }
                else //当旋转根左孩子的bf为0时，只有删除时才会出现
                {
                    newRoot = RR(root);
                    tallChange = false;
                }
            }
            //更改新的子树根
            if (p > 0)
            {
                if (root.Data < path[p - 1].Data)
                {
                    path[p - 1].Left = newRoot;
                }
                else
                {
                    path[p - 1].Right = newRoot;
                }
            }
            else
            {
                _head = newRoot; //如果旋转根为AVL树的根，则指定新AVL树根结点
            }
            return tallChange;
        }
        //root为旋转根，rootPrev为旋转根双亲结点
        private Node LL(Node root) //LL型旋转，返回旋转后的新子树根
        {
            Node rootNext = root.Left;
            root.Left = rootNext.Right;
            rootNext.Right = root;
            if (rootNext.BF == 1)
            {
                root.BF = 0;
                rootNext.BF = 0;
            }
            else //rootNext.BF==0的情况，删除时用
            {
                root.BF = 1;
                rootNext.BF = -1;
            }
            return rootNext; //rootNext为新子树的根
        }
        private Node LR(Node root) //LR型旋转，返回旋转后的新子树根
        {
            Node rootNext = root.Left;
            Node newRoot = rootNext.Right;
            root.Left = newRoot.Right;
            rootNext.Right = newRoot.Left;
            newRoot.Left = rootNext;
            newRoot.Right = root;
            switch (newRoot.BF) //改变平衡因子
            {
                case 0:
                    root.BF = 0;
                    rootNext.BF = 0;
                    break;
                case 1:
                    root.BF = -1;
                    rootNext.BF = 0;
                    break;
                case -1:
                    root.BF = 0;
                    rootNext.BF = 1;
                    break;
            }
            newRoot.BF = 0;
            return newRoot; //newRoot为新子树的根
        }
        private Node RR(Node root) //RR型旋转，返回旋转后的新子树根
        {
            Node rootNext = root.Right;
            root.Right = rootNext.Left;
            rootNext.Left = root;
            if (rootNext.BF == -1)
            {
                root.BF = 0;
                rootNext.BF = 0;
            }
            else //rootNext.BF==0的情况，删除时用
            {
                root.BF = -1;
                rootNext.BF = 1;
            }
            return rootNext; //rootNext为新子树的根
        }
        private Node RL(Node root) //RL型旋转，返回旋转后的新子树根
        {
            Node rootNext = root.Right;
            Node newRoot = rootNext.Left;
            root.Right = newRoot.Left;
            rootNext.Left = newRoot.Right;
            newRoot.Right = rootNext;
            newRoot.Left = root;
            switch (newRoot.BF) //改变平衡因子
            {
                case 0:
                    root.BF = 0;
                    rootNext.BF = 0;
                    break;
                case 1:
                    root.BF = 0;
                    rootNext.BF = -1;
                    break;
                case -1:
                    root.BF = 1;
                    rootNext.BF = 0;
                    break;
            }
            newRoot.BF = 0;
            return newRoot; //newRoot为新子树的根
        }

4. 插入与删除

4.1 插入

[cpp] view plain copy print ?
  1. public bool Add(int value) //添加一个元素  
  2.         {   //如果是空树，则新结点成为二叉排序树的根   
  3.             if (_head == null)  
  4.             {  
  5.                 _head = new Node(value);  
  6.                 _head.BF = 0;  
  7.                 return true;  
  8.             }  
  9.             p = 0;  
  10.             //prev为上一次访问的结点，current为当前访问结点  
  11.             Node prev = null, current = _head;  
  12.             while (current != null)  
  13.             {  
  14.                 path[p++] = current; //将路径上的结点插入数组  
  15.                 //如果插入值已存在，则插入失败  
  16.                 if (current.Data == value)  
  17.                 {  
  18.                     return false;  
  19.                 }  
  20.                 prev = current;  
  21.                 //当插入值小于当前结点，则继续访问左子树，否则访问右子树  
  22.                 current = (value < prev.Data) ? prev.Left : prev.Right;  
  23.             }  
  24.             current = new Node(value); //创建新结点  
  25.             current.BF = 0;  
  26.             if (value < prev.Data) //如果插入值小于双亲结点的值  
  27.             {  
  28.                 prev.Left = current; //成为左孩子  
  29.             }  
  30.             else //如果插入值大于双亲结点的值  
  31.             {  
  32.                 prev.Right = current; //成为右孩子  
  33.             }  
  34.             path[p] = current; //将新元素插入数组path的最后  
  35.             //修改插入点至根结点路径上各结点的平衡因子  
  36.             int bf = 0;  
  37.             while (p > 0)  
  38.             {   //bf表示平衡因子的改变量，当新结点插入左子树，则平衡因子+1  
  39.                 //当新结点插入右子树，则平衡因子-1  
  40.                 bf = (value < path[p - 1].Data) ? 1 : -1;  
  41.                 path[--p].BF += bf; //改变当父结点的平衡因子  
  42.                 bf = path[p].BF; //获取当前结点的平衡因子  
  43.                 //判断当前结点平衡因子，如果为0表示该子树已平衡，不需再回溯  
  44.                 //而改变祖先结点平衡因子，此时添加成功，直接返回   
  45.                 if (bf == 0)  
  46.                 {  
  47.                     return true;  
  48.                 }  
  49.                 else if (bf == 2 || bf == -2) //需要旋转的情况  
  50.                 {  
  51.                     RotateSubTree(bf);  
  52.                     return true;  
  53.                 }  
  54.             }  
  55.             return true;  
  56.         }  
  57.           
public bool Add(int value) //添加一个元素
        {   //如果是空树，则新结点成为二叉排序树的根
            if (_head == null)
            {
                _head = new Node(value);
                _head.BF = 0;
                return true;
            }
            p = 0;
            //prev为上一次访问的结点，current为当前访问结点
            Node prev = null, current = _head;
            while (current != null)
            {
                path[p++] = current; //将路径上的结点插入数组
                //如果插入值已存在，则插入失败
                if (current.Data == value)
                {
                    return false;
                }
                prev = current;
                //当插入值小于当前结点，则继续访问左子树，否则访问右子树
                current = (value < prev.Data) ? prev.Left : prev.Right;
            }
            current = new Node(value); //创建新结点
            current.BF = 0;
            if (value < prev.Data) //如果插入值小于双亲结点的值
            {
                prev.Left = current; //成为左孩子
            }
            else //如果插入值大于双亲结点的值
            {
                prev.Right = current; //成为右孩子
            }
            path[p] = current; //将新元素插入数组path的最后
            //修改插入点至根结点路径上各结点的平衡因子
            int bf = 0;
            while (p > 0)
            {   //bf表示平衡因子的改变量，当新结点插入左子树，则平衡因子+1
                //当新结点插入右子树，则平衡因子-1
                bf = (value < path[p - 1].Data) ? 1 : -1;
                path[--p].BF += bf; //改变当父结点的平衡因子
                bf = path[p].BF; //获取当前结点的平衡因子
                //判断当前结点平衡因子，如果为0表示该子树已平衡，不需再回溯
                //而改变祖先结点平衡因子，此时添加成功，直接返回
                if (bf == 0)
                {
                    return true;
                }
                else if (bf == 2 || bf == -2) //需要旋转的情况
                {
                    RotateSubTree(bf);
                    return true;
                }
            }
            return true;
        }


4.2 删除

[cpp] view plain copy print ?
  1. private void RemoveNode(Node node)  
  2.        {  
  3.            Node tmp = null;  
  4.            //当被删除结点存在左右子树时   
  5.            if (node.Left != null && node.Right != null)  
  6.            {  
  7.                tmp = node.Left; //获取左子树  
  8.                path[++p] = tmp;  
  9.                while (tmp.Right != null) //获取node的中序遍历前驱结点，并存放于tmp中  
  10.                {   //找到左子树中的最右下结点   
  11.                    tmp = tmp.Right;  
  12.                    path[++p] = tmp;  
  13.                }  
  14.                //用中序遍历前驱结点的值代替被删除结点的值   
  15.                node.Data = tmp.Data;  
  16.                if (path[p - 1] == node)  
  17.                {  
  18.                    path[p - 1].Left = tmp.Left;  
  19.                }  
  20.                else  
  21.                {  
  22.                    path[p - 1].Right = tmp.Left;  
  23.                }  
  24.            }  
  25.            else //当只有左子树或右子树或为叶子结点时  
  26.            {   //首先找到惟一的孩子结点   
  27.                tmp = node.Left;  
  28.                if (tmp == null) //如果只有右孩子或没孩子  
  29.                {  
  30.                    tmp = node.Right;  
  31.                }  
  32.                if (p > 0)  
  33.                {  
  34.                    if (path[p - 1].Left == node)  
  35.                    {   //如果被删结点是左孩子  
  36.                        path[p - 1].Left = tmp;  
  37.                    }  
  38.                    else  
  39.                    {   //如果被删结点是右孩子  
  40.                        path[p - 1].Right = tmp;  
  41.                    }  
  42.                }  
  43.                else  //当删除的是根结点时  
  44.                {  
  45.                    _head = tmp;  
  46.                }  
  47.            }  
  48.            //删除完后进行旋转，现在p指向实际被删除的结点   
  49.            int data = node.Data;  
  50.            while (p > 0)  
  51.            {   //bf表示平衡因子的改变量，当删除的是左子树中的结点时，平衡因子-1  
  52.                //当删除的是右子树的孩子时，平衡因子+1   
  53.                int bf = (data <= path[p - 1].Data) ? -1 : 1;  
  54.                path[--p].BF += bf; //改变当父结点的平衡因子  
  55.                bf = path[p].BF; //获取当前结点的平衡因子  
  56.                if (bf != 0) //如果bf==0，表明高度降低，继续后上回溯  
  57.                {  
  58.                    //如果bf为1或-1则说明高度未变，停止回溯，如果为2或-2，则进行旋转  
  59.                    //当旋转后高度不变，则停止回溯  
  60.                    if (bf == 1 || bf == -1 || !RotateSubTree(bf))  
  61.                    {  
  62.                        break;  
  63.                    }  
  64.                }  
  65.            }  
  66.        }  
  67.         
 private void RemoveNode(Node node)
        {
            Node tmp = null;
            //当被删除结点存在左右子树时
            if (node.Left != null && node.Right != null)
            {
                tmp = node.Left; //获取左子树
                path[++p] = tmp;
                while (tmp.Right != null) //获取node的中序遍历前驱结点，并存放于tmp中
                {   //找到左子树中的最右下结点
                    tmp = tmp.Right;
                    path[++p] = tmp;
                }
                //用中序遍历前驱结点的值代替被删除结点的值
                node.Data = tmp.Data;
                if (path[p - 1] == node)
                {
                    path[p - 1].Left = tmp.Left;
                }
                else
                {
                    path[p - 1].Right = tmp.Left;
                }
            }
            else //当只有左子树或右子树或为叶子结点时
            {   //首先找到惟一的孩子结点
                tmp = node.Left;
                if (tmp == null) //如果只有右孩子或没孩子
                {
                    tmp = node.Right;
                }
                if (p > 0)
                {
                    if (path[p - 1].Left == node)
                    {   //如果被删结点是左孩子
                        path[p - 1].Left = tmp;
                    }
                    else
                    {   //如果被删结点是右孩子
                        path[p - 1].Right = tmp;
                    }
                }
                else  //当删除的是根结点时
                {
                    _head = tmp;
                }
            }
            //删除完后进行旋转，现在p指向实际被删除的结点
            int data = node.Data;
            while (p > 0)
            {   //bf表示平衡因子的改变量，当删除的是左子树中的结点时，平衡因子-1
                //当删除的是右子树的孩子时，平衡因子+1
                int bf = (data <= path[p - 1].Data) ? -1 : 1;
                path[--p].BF += bf; //改变当父结点的平衡因子
                bf = path[p].BF; //获取当前结点的平衡因子
                if (bf != 0) //如果bf==0，表明高度降低，继续后上回溯
                {
                    //如果bf为1或-1则说明高度未变，停止回溯，如果为2或-2，则进行旋转
                    //当旋转后高度不变，则停止回溯
                    if (bf == 1 || bf == -1 || !RotateSubTree(bf))
                    {
                        break;
                    }
                }
            }
        }

【数据结构】平衡树
大雨的博客
03-30 751
平衡树作为数据结构领域的重要成员，以其独特的自平衡特性，为数据的存储、检索和动态更新提供了高效的解决方案。我们深入剖析了常见的平衡树类型，如严格平衡的 AVL 树、近似平衡的红黑树以及结构独特的 2 - 3 树，了解了它们各自的平衡策略、插入删除等操作原理。在实际应用中，平衡树在数据库索引、搜索引擎等关键领域发挥着不可替代的作用，大大提升了系统的性能和效率。然而，平衡树的知识体系远不止于此，它还有许多值得我们深入探索的地方。
【数据结构】AVL树——平衡二叉搜索树
最新发布
2301_79796701的博客
05-25 2015
平衡树：左子树的高度等于右子树的高度不平衡树：左子树的高度不等于等于右子树的高度二叉搜索树很难是一颗平衡树。对二叉树进行插入和删除的操作，或插入大量的数据不够随机，都会是使二叉搜索树不够平衡。极端情况下，二叉树会退化成类似链表的结构，那么二叉搜索树查询数据的效率荡然无存。在二叉树的基础上加入平衡的概念就是平衡二叉搜索树，也叫AVL树。AVL树也不是一颗绝对的平衡树，AVL树的平衡是相对的，它允许左子树和右子树的高度为 1 ，但不能超过 1。
平衡树
weixin_38168139的博客
08-05 157
一、二叉查找树 　　简介 　　　　二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 　　　　（1）若左子树不空，则左子树上所有节点的值均小于它的根节点的值； 　　　　（2）若右子树不空，则右子树上所有节点的值均大于它的根节点的值； 　　　　（3）左、右子树也分别为二叉排序树； 　　　　（4）没有键值相等的节点。 　　1.二叉查找树的遍历 　　　　在二叉查找...
平衡树详解
WerChange的OI博客
01-11 4345
笔记——树状数据结构篇
C语言实现高效平衡树：AVL树详解
AVL树是一种自平衡二叉搜索树，由俄国数学家Adelson-Velsky和Landis首次提出，因此得名。AVL树在每次插入或删除节点后，都能够通过旋转操作来保持树的平衡，从而保证搜索的效率。在C语言实现AVL树时，需要掌握几个...
平衡二叉树（AVL树）
Ronz 的博客
01-24 7626
一、平衡二叉树概述 1.1 什么是平衡二叉树 平衡二叉树也叫 AVL 树。平衡二叉树是具有以下特点的二叉查找树：它是一棵空树或它的左右两个子树的高度差的绝对值不超过 1， 并且左右两个子树都是一棵平衡二叉树。 图一 平衡二叉树 图二 非平衡二叉树 1.2 为什么要有平衡二叉树 在上一篇文章 二叉排序树 中对二叉排序树做了介
【C++】AVL树详解
muyuteacher的博客
02-29 1389
AVL树是一种高效的自平衡二叉搜索树，在计算机科学领域得到广泛应用。本文主要介绍了AVL树的概念、节点定义、AVL树的实现以及验证，其中包括对平衡因子的解释，研究在插入节点时，如何通过旋转来调节平衡因子来保持AVL树的特性。
平衡树详解之AVL
Vurteon的专栏
12-07 2306
前言：          本文介绍了AVL的插入和删除， 首先让我们想一下很简单的二分查找，其效率为O(lgn)，这是很好的，而大多数时候在数据的处理涉及到插入和删除，但是，线型表仅仅使用于查找，所以—依据二分查找性质的二叉排序树出现了，但是却出现了由于树的形状而影响查找效率的情况，导致可能会出现O(n)的情况，一般二叉树的查找复杂度是和深度有关，所以如果能够控制二叉排序树的形状，那么就能够控制
AVL平衡树详解
coderlong的博客
03-07 337
title: AVL平衡树删除增加操作 date: 2018-3-7 23:59:17 categories: - java tags: - java - java集合 - JDK 在看MySQL索引结构的时候，就对什么B树，B+树，BST有点混淆了。 等到在遇到AVL树，JDK的HashMap实现红黑树的时候，就更加搞不明白了， 所以...
平衡树概述
lvmaooi的博客
03-28 1875
平衡树是排序二叉树的（SBT）的升级版。就是采取各种手段让排序二叉树变得更平衡，不然在数据极端的情况下，SBT退化成一条链，复杂度也退化成n2n2n^2了。总的来说，就是为了不被丧病出题人卡极端数据发明的算法。 \\ 我们直接把三种写法放在一起（可能会有点长，不过将就看吧）。 平衡树——替罪羊树概述 自从写了平衡树之后就整个人都不好了，我是个蒟蒻，打个200行的代码就不咋调得出来。...
平衡树（Balanced Tree）
qq_69100706的博客
05-05 846
平衡树（Balanced Tree）是一种特殊的二叉查找树（Binary Search Tree, BST），其主要目的是在保持二叉查找树基本特性的基础上，通过额外的约束条件确保树的高度尽可能均衡，从而保证在插入、删除和查找等操作时能保持较高的性能。平衡树的关键特性是任何节点的两个子树的高度差最多为1，这有助于确保在最坏情况下的操作时间复杂度接近于O(log n)，其中n是树中节点的数量。：如同一般的二叉查找树，平衡树中的每个节点的值均大于其左子树中所有节点的值，且小于其右子树中所有节点的值。
平衡树以及AVL树
weixin_30794499的博客
01-15 164
　　平衡树是计算机科学中的一类数据结构。平衡树是计算机科学中的一类改进的二叉查找树。一般的二叉查找树的查询复杂度是跟目标结点到树根的距离（即深度）有关，因此当结点的深度普遍较大时，查询的均摊复杂度会上升，为了更高效的查询，平衡树应运而生了。 　　在这里，平衡指所有叶子的深度趋于平衡，更广义的是指在树上所有可能查找的均摊复杂度偏低。 　　几乎所有平衡树的操作都基于树操作，通过旋转操作可以使得树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值