树：平衡二叉树

最新推荐文章于 2022-11-13 17:32:42 发布
最新推荐文章于 2022-11-13 17:32:42 发布
阅读量152 收藏
点赞数
分类专栏： 数据结构&算法 文章标签： 数据结构 算法 树 平衡二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011976388/article/details/107435245
版权

1，二叉排序树问题

  • 对于一个有序数组{1, 2, 3, 4, 5}，其生成的二叉排序树如下；由图可见，最终形成一个类似单链表形式的二叉树，对插入速度没有影响，但是对于查询速度明显减低，不能通过BST进行查询，时间复杂度为O(n)；需要对二叉排序树这种现象进行优化，则引入平衡二叉树(AVL)
    在这里插入图片描述

2，平衡二叉树基本介绍

  • 平衡二叉树也叫平衡二叉搜索树(self-balancing binary search tree)，又被称为AVL树，可以保证较高的二分查找效率
  • 平衡二叉树特点：是一颗空树或者左右子树的高度差绝对值小于1的树，并且左右子树都是平衡二叉树；平衡二叉树的实现有红黑树，AVL，替罪羊树，Treap，伸展树等
  • 平衡二叉树的平衡保证通过单旋转（左旋转，右旋转）和双旋转完成

3，左旋转

  • 左旋触发条件：当前节点的左树高度与右树高度差值大于1，进行左旋，重新保证树的平衡
  • 将当前节点重新初始化为一个新节点newNode
  • 将newNode的右侧节点，设置为当前节点的右侧节点
  • 将newNode的左侧节点，设置为当前节点左侧节点的右侧节点
  • 将当前节点的权值设置为当前节点左侧节点的权值，此时完成左侧节点上浮
  • 将当前节点的左侧节点设置为左侧节点的左侧节点，当前节点的原始左侧节点已经上浮，挂空后等待GC回收
  • 将当前节点的右侧节点设置为newNode
  • 此时完成左旋，示意图如下，节点40表示当前节点
    在这里插入图片描述

4，右旋转

  • 右旋触发条件：当前节点的右树高度与左树高度差值大于1，进行右旋，重新保证树的平衡
  • 将当前节点重新初始化为一个新节点newNode
  • 将newNode的左侧节点，设置为当前节点的左侧节点
  • 将newNode的右侧节点，设置为当前节点右侧节点的左侧节点
  • 将当前节点的权值设置为当前节点右侧节点的权值，此时完成右侧节点上浮
  • 将当前节点的右侧节点设置为右侧节点的右侧节点，当前节点的原始右侧节点已经上浮，挂空后等待GC回收
  • 将当前节点的左侧节点设置为newNode
  • 此时完成右旋，示意图如下，节点40表示当前节点
    在这里插入图片描述

5，双旋转

  • 双旋转触发条件：双旋转是先左旋转，后右旋转（或者相反）。以基本旋转为右旋转分析，左旋转相反
  • 当前节点为根节点的二叉树已经满足右旋转标准，但是其左侧子节点的右侧子树高度高于左侧子树；因为在右旋时需要将左侧子节点的右侧子树挂到新建节点的左侧，直接右旋完成后，会发现高度差依然是2，不过是右侧比左侧高2，又符合左旋标准，进入死循环，如图：
    在这里插入图片描述
    • 因为左侧子节点在右旋时高度会升高1，其左侧节点如果比其右侧节点高度高1，则旋转后叶子节点高度相同；如果其左侧节点比其右侧节点高度少1，则旋转后，其左侧节点再高一层，右侧高度不变，高差依旧为2，又需要左旋，进入死循环
  • 此时处理办法是，先对子树进行旋转；基本旋转为右旋时，如果当前节点左侧子节点的右子树高度高于左子树，则以该左侧节点为根节点，首先进行一次左旋，保证在该子树上，左子树节点高度高于右子树节点；
    在这里插入图片描述
  • 此时再进行基本的右侧旋转，则最终获取到的AVL树就是标准的AVL树
    在这里插入图片描述

6，代码实现

package com.self.datastructure.tree.binarytree;

import lombok.Data;

/**
 * 平衡二叉树
 *
 * @author PJ_ZHANG
 * @create 2020-04-09 9:11
 **/
public class AVLTree {

    public static void main(String[] args) {
        MyAVLTree myAVLTree = new MyAVLTree();
        // 增加节点
        // 删除节点
        // 遍历树
    }

    static class MyAVLTree {
        // 根节点
        private Node root;

        /**
         * 获取根节点
         *
         * @return 根节点
         */
        public Node getRoot() {
            return root;
        }

        /**
         * 删除节点
         * 删除节点是在
         *
         * @param value
         */
        public void delNode(int value) {
            if (null == root) {
                return;
            }
            // 删除根节点
            if (root.getValue() == value && null == root.getLeftNode() && null == root.getRightNode()) {
                root = null;
                return;
            }
            doDelNode(null, root, value);
        }

        private void doDelNode(Node parentNode, Node node, int value) {
            // 删除节点
            deleteNode(parentNode, node, value);
            // 节点删除完成后, 刷新AVL树
            // 删除不同于添加, 添加肯定添加到叶子节点, 所以可以直接进行树旋转处理
            // 删除可能在中间节点删除, 需要重新构造一次, 从根节点开始构造
            refreshAVLTree(root);
        }

        /**
         * 重构AVL树
         * @param node 当前递归到的节点
         */
        private void refreshAVLTree(Node node) {
            if (null == node) {
                return;
            }
            // 先处理左边
            refreshAVLTree(node.getLeftNode());
            // 再处理右边
            refreshAVLTree(node.getRightNode());
            // 进行旋转
            rotate(node);
        }

        /**
         * 删除节点
         *
         * @param parentNode 父节点
         * @param node 当前递归到的节点
         * @param value 要删除的值
         */
        private void deleteNode(Node parentNode, Node node, int value) {
            if (node.getValue() < value) {
                deleteNode(node, node.getRightNode(), value);
            } else if (node.getValue() > value) {
                deleteNode(node, node.getLeftNode(), value);
            } else {
                // 找到节点, 进行节点删除
                // 对当前节点的权值进行替换, 用左侧节点的最右侧节点进行替换
                if (null == node.getLeftNode() && null == node.getRightNode()) {
                    // 当前节点为叶子节点
                    if (parentNode.getRightNode() == node) {
                        parentNode.setRightNode(null);
                    } else if (parentNode.getLeftNode() == node) {
                        parentNode.setLeftNode(null);
                    }
                    node = parentNode;
                } else if (null == node.getLeftNode() || null == node.getRightNode()) {
                    // 当前节点为父节点, 但只有单子节点
                    // 因为AVL树的平衡属性, 节点如果只有单子节点, 则该子节点下不可能再有子节点, 如果往这部分加节点, 则会触发旋转
                    // 如果左侧节点为空, 则将右侧节点的权值赋给该节点, 并将该节点的右侧节点断开
                    // 如果右侧节点为空, 则将左侧节点的权值赋给该节点, 并将该节点的左侧节点断开
                    if (null == node.getLeftNode()) {
                        node.setValue(node.getRightNode().getValue());
                        node.setRightNode(null);
                    } else if (null == node.getRightNode()) {
                        node.setValue(node.getLeftNode().getValue());
                        node.setLeftNode(null);
                    }
                } else {
                    // 当前节点为父节点, 并且直接子节点完整
                    // 取左子节点的最右侧节点替换该节点
                    // 取左侧节点为临时节点
                    // 取当前节点为父节点
                    Node tmpNode = node.getLeftNode();
                    parentNode = node;
                    // 一直取左侧节点的右侧节点, 直到右侧节点为空, 说明已经获取到左树的最大值
                    for (;null != tmpNode.getRightNode();) {
                        parentNode = tmpNode;
                        tmpNode = tmpNode.getRightNode();
                    }
                    // 将Node的值设置为左树最大节点值
                    node.setValue(tmpNode.getValue());
                    // 接着需要将该节点断开
                    // 该节点可能是父节点的左侧节点, 也可能是右侧节点, 需要分支处理
                    // 同样, 该节点可能存在左侧节点, 需要重新连接
                    // 如果节点是左侧节点, 并且存在左侧节点, 则直接将该节点的左侧节点设置为父节点的左侧节点
                    // 如果节点是右侧节点, 并且存在左侧节点, 则直接将该节点的左侧节点设置为父节点的右侧节点
                    if (tmpNode == parentNode.getLeftNode()) {
                        parentNode.setLeftNode(tmpNode.getLeftNode());
                    } else if (tmpNode == parentNode.getRightNode()) {
                        parentNode.setRightNode(tmpNode.getLeftNode());
                    }
                }
            }
        }

        /**
         * 添加节点
         *
         * @param value 要添加的节点
         */
        public void addNode(int value) {
            if (null == root) {
                root = new Node(value);
                return;
            }
            doAddNode(root, value);
        }

        private void doAddNode(Node parentNode, int value) {
            if (null == parentNode) {
                return;
            }
            // 添加节点
            if (parentNode.getValue() < value) {
                if (null == parentNode.getRightNode()) {
                    parentNode.setRightNode(new Node(value));
                } else {
                    doAddNode(parentNode.getRightNode(), value);
                }
            } else if (parentNode.getValue() > value) {
                if (null == parentNode.getLeftNode()) {
                    parentNode.setLeftNode(new Node(value));
                } else {
                    doAddNode(parentNode.getLeftNode(), value);
                }
            } // 等于不添加

            // 节点添加完成后, 进行左旋右旋处理
            // 因为添加节点是递归加的, 所以对于添加节点路径上的每一个节点都会进行该步操作
            // 节点旋转, 构建平衡树
            rotate(parentNode);
        }

        /**
         * 进行左旋右旋处理,
         * 添加和删除节点都涉及该步
         * @param currNode
         */
        private void rotate(Node currNode) {
            // 如果左侧树比右侧树的高度差大于1, 则右旋
            if (getLeftHeight(currNode) - getRightHeight(currNode) > 1) {
                // 如果左侧树的右侧节点层数比左侧树的左侧节点层数高, 则先进行一次左旋
                if (null != currNode.getLeftNode() && getLeftHeight(currNode.getLeftNode()) < getRightHeight(currNode.getLeftNode())) {
                    leftRotate(currNode.getLeftNode());
                }
                rightRotate(currNode);
            }
            // 如果右侧树比左侧树的高度小于1, 则左旋
            else if (getRightHeight(currNode) - getLeftHeight(currNode) > 1) {
                // 如果右侧数的左侧子节点层数比右侧子节点层数大, 则先进行一次右旋
                if (null != currNode.getRightNode() && getRightHeight(currNode.getRightNode()) < getLeftHeight(currNode.getRightNode())) {
                    rightRotate(currNode.getLeftNode());
                }
                leftRotate(currNode);
            }
        }

        /**
         * 右旋
         * 重新构造当前节点为新节点
         * 将新节点的右侧节点设置为当前节点的右侧节点
         * 将新节点的左侧节点设置为当前节点的左侧节点的右侧节点
         * 将当前节点的权值设置为左侧节点的权值
         * 将当前节点的左侧节点设置为左侧节点的左侧节点
         * 将当前节点的右侧节点设置为新节点
         *
         * @param node
         */
        public void rightRotate(Node node) {
            Node newNode = new Node(node.getValue());
            newNode.setRightNode(node.getRightNode());
            newNode.setLeftNode(node.getLeftNode().getRightNode());
            node.setValue(node.getLeftNode().getValue());
            node.setLeftNode(node.getLeftNode().getLeftNode());
            node.setRightNode(newNode);
        }

        /**
         * 左旋
         * 重新构造当前节点为新节点
         * 将新节点的左侧节点设置为当前节点的左侧节点
         * 将新节点的右侧节点设置为当前节点的右侧节点的左侧节点
         * 将当前节点的权值设置为右侧节点的权值
         * 将当前节点的右侧节点设置为右侧节点的右侧节点
         * 将当前节点的左侧节点设置为新节点
         * @param node 需要处理的子树根节点
         */
        public void leftRotate(Node node) {
            Node newNode = new Node(node.getValue());
            newNode.setLeftNode(node.getLeftNode());
            newNode.setRightNode(node.getRightNode().getLeftNode());
            node.setValue(node.getRightNode().getValue());
            node.setRightNode(node.getRightNode().getRightNode());
            node.setLeftNode(newNode);
        }

        /**
         * 获取左侧树高度
         * @param node
         * @return
         */
        public int getRightHeight(Node node) {
            if (null == node.getRightNode()) {
                return 0;
            }
            return getHeight(node.getRightNode());
        }

        /**
         * 获取右侧树高度
         * @param node
         * @return
         */
        private int getLeftHeight(Node node) {
            if (null == node.getLeftNode()) {
                return 0;
            }
            return getHeight(node.getLeftNode());
        }

        /**
         * 获取树高度
         * @param node
         * @return
         */
        public int getHeight(Node node) {
            int height = 0;
            int leftHeight = 0;
            int rightHeight = 0;
            if (null != node.getLeftNode()) {
                leftHeight += getHeight(node.getLeftNode());
            }
            if (null != node.getRightNode()) {
                rightHeight = getHeight(node.getRightNode());
            }
            height = Math.max(leftHeight, rightHeight);
            return height + 1;
        }

        /**
         * 中序遍历
         */
        public void middleShowDetails() {
            doMiddleShowDetails(root);
        }

        private void doMiddleShowDetails(Node node) {
            if (null == node) {
                return;
            }
            doMiddleShowDetails(node.getLeftNode());
            System.out.println(node);
            doMiddleShowDetails(node.getRightNode());
        }

    }

    @Data
    static class Node {

        // 节点权值
        private int value;

        // 左节点
        private Node leftNode;

        // 右节点
        private Node rightNode;

        public Node() {}

        public Node(int value) {
            this.value = value;
        }

        public String toString() {
            return "Node: [value = " + value + "]";
        }

    }

}
传说中的靖哥哥
关注
专栏目录
快速理解平衡二叉树、B-tree、B+tree、B*tree
jacke121的专栏
10-18 3万+
快速理解平衡二叉树、B-tree、B+tree、B*tree
(王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转
快乐江湖的博客
11-20 3689
文章目录一：AVL树基本概念二：AVL树实现原理（1）构建AVL树（2）旋转方法A：右单旋转调整(BF>0)B：左单旋转调整(BF<0)C：先左后右双旋转调整D：先右后左双旋转调整（3）构建演示三：AVL树相关代码 一：AVL树基本概念 二叉排序树有一个缺陷：树的高度会直接影响其查找效率，树越高效率越差，效率最差时为一棵单分支树 平衡二叉树(Self-Balancing Binary Search Tree)：它首先是一颗二叉排序树，其中每个节点的左右子树高度之差绝对值不超过1。将二叉树上结点
AVL平衡二叉树知识点
qq_43699776的博客
05-18 208
1、定义 任意结点的左、右子树高度差的绝对值不超过1，将这样的二叉树称为平衡二叉树。 左子树与右子树的高度差为该节点的平衡因子，平衡因子值只能是-1，1，0 2、插入 A、二叉排序树保证平衡的基本思想：每当在二叉排序树中插入（或删除）一个结点时，首先检查其插入路径上的结点是否因为此次操作而 导致了不平衡。若导致了不平衡，则先找到插入路径上离插入结点最近的平衡因子的绝对值大于1的结点A，再对以A为根的子树，在保持 二叉排序树特性的前提下，调整各结点的位置关系，使之重新达到平衡。 B、在新节点插入后，若造成查
索引 ----- 二叉树、平衡二叉树、b-tree、b+tree详解
qq_36098284的博客
05-03 1万+
本文是转载+自我梳理主要讲的是索引中使用树这种数据结构是怎么存储的。以及从二叉树开始的4种树的应用。我个人认为参考价值最大的就是b+tree和b-tree都是具体怎么存数据的（相当于优化部分）B+树索引是B+树在数据库中的一种实现，是最常见也是数据库中使用最为频繁的一种索引。B+树中的B代表平衡（balance），而不是二叉（binary），因为B+树是从最早的平衡二叉树演化而来的。在讲B+树之前...
如何构建平衡二叉树（AVL树）
此去经年
10-19 1万+
一、基本概念：         平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 二、四种旋转情况        当我们对AVL树进行删除或者插入操作时，有可能会导致其左右子树高度差不超过1的性质遭到破坏，因此需要进行旋转操作来调整
平衡二叉树（AVL）图解与实现
热门推荐
小张的专栏
10-31 6万+
个人技术博客：http://blog.ztgreat.cn 平衡二叉树（Balanced BinaryTree）又被称为AVL树。它具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。   平衡二叉树一般是一个有序树，它具有二叉树的所有性质，其遍历操作和二叉树的遍历操作相同。但是由于其对二叉树施加了额外限制，因而其添加、删除操作都必须...
1077: 平衡二叉树的判定
chen10151015的博客
05-18 1038
题目描述 编写程序判断给定的二叉树是否是平衡二叉树。 输入 二叉树的先序序列。 输出 如果是平衡二叉树，输出yes！，否者输出no！ 样例输入 AB##C## 样例输出 yes！ 平衡二叉树：若一颗二叉树中每个结点的左、右子树的高度至多相差1，则称此二叉树为平衡二叉树 某结点的高度：即结点的最大层次。根节点为第一层，它的孩子结点为第二层，以此类推，取最大层次 平衡因子：该结点左子树的高度减去右子树的高度 结论：若一颗二叉树中所有结点的平衡因子的绝对值小于等于1，该二叉树称为平衡二叉树 举例如下图所示：
二叉树：平衡二叉树
最新发布
qq_46785243的博客
11-13 1660
平衡二叉树
数据结构课程设计：平衡二叉树.doc
06-13
数据结构课程设计中，平衡二叉树是一种关键的数据结构，它的目标是确保树的高度尽可能小，从而保持查找、插入和删除操作的高效性。平衡二叉树的主要特点是它左右两个子树的高度差不超过1，这使得在最坏情况下，搜索...
算法9-9~9-12：平衡二叉树的基本操作
izhengtl2021的博客
07-01 792
平衡二叉树又称AVL树，它是一种具有平衡因子的特殊二叉排序树。平衡二叉树或者是一棵空树，或者是具有以下几条性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值； 它的左右子树也分别为平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。 若将二叉树上结点的平衡因子定义为该结点...
编程笔试(解析及代码实现)：平衡二叉树判断。输入一棵二叉树，判断该二叉树是否是平衡二叉树
Show Me The Code
09-17 997
编程笔试(解析及代码实现)：平衡二叉树判断。输入一棵二叉树，判断该二叉树是否是平衡二叉树 目录 题目描述 代码实现 题目描述 平衡二叉树判断。输入一棵二叉树，判断该二叉树是否是平衡二叉树。 代码实现 题目描述 平衡二叉树判断。输入一棵二叉树，判断该二叉树是否是平衡二叉树。 代码实现 # -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val
LeetCode110 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
CourageKang的博客
09-07 2159
给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *rig...
二叉树、平衡二叉树、B- tree、B+ tree 基本概念
时光钟摆
07-14 9916
1 二叉树 二叉树binary tree是指每个节点最多含有两个子树的树结构。 特点： 1.所有节点最多拥有两个子节点，即度不大于2 2.左子树的键值小于根的键值，右子树的键值大于根的键值。 因为二叉树只是定义了简单的结构，所以存在多种深度可能，导致二叉树的效率低，所以引入了平衡二叉树。 2 平衡二叉树 2.1 avl树 ...
平衡二叉树的调整(详解 LL、RR、LR、RL)
whr
05-21 2万+
当向一棵AVL树中插入一个新的结点，有可能会破坏树的平衡，这时就需要调整这棵树，本文将详细讲解各种调整的过程
普里姆（Prim）算法（P算法）：修路问题
zp_zhang的博客
07-18 2792
1，应用场景—修路问题 如图，此时有7个村庄['A', 'B', 'C', 'D', 'E', 'F', 'G']，现在需要把这7个村庄连通 村庄之间的连接线表示可能修路的图示，权值表示举例 此时，如果想要把7个村庄连通，怎么才能让连接的路程最短？ 此时应该尽可能的寻找少的线路，保证每条线路最短，最终达到整体线路最短（该部分有点类似贪心，但是贪心的最终结果不一定是最优解） 2，最小生成树问题 修路问题本身就是最小生成树（Minimum Cost Spanning Tree）问题，简称MST：给定一个
弗洛伊德（Floyd）算（F算法）— 最短寻径问题
zp_zhang的博客
07-18 2244
1，应用场景—最短寻径问题 弗洛伊德算法与迪杰斯特拉算法解决问题完全一致，这是解题思路不同 2，弗洛伊德算法介绍 和迪杰斯特拉（Dijkstra）算法一样，弗洛伊德（Floyd）算法也是一种用于寻找加权图中顶点间最短路径的算法，该算法创始人为1978年图灵奖获得者罗比特 · 弗洛伊德 与迪杰斯塔拉算法不同的是：迪杰斯特拉算法基于一个给定的出发顶点，求出该顶点到其他顶点的最短距离；弗洛伊德算法将每一个顶点作为出发顶点，所以需要求出每一个顶点到其他顶点的最短路径； 迪杰斯特拉算法最后给出的结果是一个一维
骑士周游（马踏棋盘）问题
zp_zhang的博客
07-18 1516
1，马踏棋盘算法介绍 马踏棋盘问题也被称为骑士周游问题 将马随机放在国际象棋的8*8的棋盘中的某个格子里，马按照走棋规则（日子）进行移动。要求每个方格只进入一次，走遍64个方格 2，马踏棋盘算法思路分析 马踏棋盘算法是对图的深度遍历优先（DFS）的使用，通过递归加回溯实现对问题的解决，同时可使用贪心算法对最终算法进行优化 从一点出发，对该点标记为已访问，并寻找该点通过日子走法，下一步可能访问的点坐标的集合 如果存在对应的点坐标集合，并且存在点未访问，则按顺序对集合中的未访问坐标点进行递归访问，即重复
排序算法：时间复杂度和空间复杂度
zp_zhang的博客
07-18 1413
1，常见的排序分类 排序算法分为内部排序和外部排序两种，内部排序是完全在内存中完成，外部排序需要使用外部介质，如硬盘，中间件等，此次排序算法只考虑内部排序 内部排序算法可分为：插入排序（直接插入排序，希尔排序），选择排序（简单选择排序，堆排序），交换排序（冒泡排序，快速排序），归并排序，基数排序等 2，时间复杂度 时间频度：一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句的执行次数多，它花费的时间就多。一个算法中语句的执行次数称为语句频度或者时间频度，记为T(n)。在数量及运算下，时间
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值