平衡二叉树的实现与总结(Java)

平衡二叉树

平衡二叉树的引入

案例:给定数组{1,2,3,4,5,6},要求创建一棵二叉排序树(BST)。

按照此数组创建的二叉排序树如图所示:
二叉排序树

分析上图BST树可发现如下问题所在:

  • 左子树全部为空,从形式上看,更像一个单链表
  • 查询速度明显降低,不能发挥BST的优势,因为每次还需要比较左子树,其查询速度比单链表还慢

基于这些问题,我们的解决方案就是引入平衡二叉树

平衡二叉树基本介绍

  • 平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树,可以保证查询效率较高。
  • 平衡二叉树具有以下特点:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树。
  • 平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。
  • 平衡二叉树一定是二叉排序树,反之不一定成立。

平衡二叉树的案例分析


情况一:单旋转(右旋转)
给定数组{15,9,18,7,12,5},分析如下图所示
图解分析
步骤分析

  • 创建一个与当前节点值相同的新节点
  • 新节点的右子节点指向当前节点的右子节点
  • 新节点的左子节点指向当前节点的左子节点的右子节点
  • 将当前节点的左子节点的值赋给当前节点
  • 当前节点的左子节点指向当前节点的左子节点的左子节点
  • 当前节点的右子节点指向新节点

情况二:单旋转(左旋转)
给定数组{5,3,8,7,10,11},分析如下图所示
图解分析
步骤分析

  • 首先new一个新节点,新节点的值与当前节点相同
  • 新节点的左子节点指向当前节点的左子节点
  • 新节点的右子节点指向当前节点的右子节点的左子节点
  • 将当前节点的右子节点的值赋给当前节点
  • 当前节点的右子节点指向当前节点的右子节点的右子节点
  • 当前节点的左子节点指向新节点

情况三:双旋转
给定数组{5,3,8,7,10,6},分析如下图

图解分析发现无法用左旋转解决问题,此时应采用双旋转。
即先将以根节点的右子节点为根节点树先右旋转,在将整棵树左旋转,旋转方法与上面分析的一样。注:还有一种情况这里不做分析,请动动脑筋自行分析


代码实现

先创建一个节点类,封装数据。(注:主要实现方法都写在这个类中,请仔细分析。)

/**
 * 封装节点的类
 */
class Node {
    
    
    int value;
    Node left;
    Node right;

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

    /**
     * 添加方法
     *
     * @param node 待添加的节点
     */
    public void add(Node node) {
    
    
        if (node.value < this.value) {
    
    
            if (this.left == null) {
    
    
                this.left = node;
            } else {
    
    
                this.left.add(node);
            }
        } else {
    
    
            if (this.right == null) {
    
    
                this.right = node;
            } else {
    
    
                this.right.add(node);
            }
        }

        if (getRightHeight() - getLeftHeight() > 1) {
    
    
            //进到这里说明当前节点的右子树高度与左子树高度的差值大于1
            if (this.right != null &&
                    this.right.getLeftHeight() > this.right.getRightHeight()) {
    
    
                //进入这里说明当前节点的右子节点的左子树高度大于右子树高度
                //需要先将右子节点进行右旋转
                this.right.rightRotation();
            }
            //左旋转
            leftRotation();
            //执行到这里已经将二叉树调整为平衡二叉树,切记结束方法
            return;
        }
        if (getLeftHeight() - getRightHeight() > 1) {
    
    
            //进到这里说明当前节点的左子树高度与右子树高度的差值大于1
            if (this.left != null &&
                    this.left.getRightHeight() > this.left.getLeftHeight()) {
    
    
                //进入这里说明当前节点的左子节点的右子树高度大于左子树高度
                //需要先将左子节点进行左旋转
                this.left.leftRotation();
            }
            //右旋转
            rightRotation();
        }
    }

    /**
     * 中序遍历
     */
    public void inorder() {
    
    
        if (this.left != null) {
    
    
            this.left.inorder();
        }
        System.out.println(this);
        if (this.right != null) {
    
    
            this.right.inorder();
        }
    }

    /**
     * 获取高度的方法
     *
     * @return 返回当前以当前节点为父节点的树的高度
     */
    public int getHeight() {
    
    
        return Math.max(this.left == null ? 0 : this.left.getHeight(),
                this.right == null ? 0 : this.right.getHeight()) + 1;
    }

    /**
     * 获取左子树高度
     *
     * @return 返回以当前节点的左子节点为父节点的树的高度
     */
    public int getLeftHeight() {
    
    
        if (this.left == null) {
    
    
            return 0;
        }
        return this.left.getHeight();
    }

    /**
     * 获取右子树高度
     *
     * @return 返回以当前节点的右子节点为父节点的树的高度
     */
    public int getRightHeight() {
    
    
        if (this.right == null) {
    
    
            return 0;
        }
        return this.right.getHeight();
    }

    /**
     * 左旋转
     */
    public void leftRotation() {
    
    
        //1.首先new一个新节点,新节点的值与当前节点相同
        Node newNode = new Node(this.value);
        //2.新节点的左子节点指向当前节点的左子节点
        newNode.left = this.left;
        //3.新节点的右子节点指向当前节点的右子节点的左子节点
        newNode.right = this.right.left;
        //4.将当前节点的右子节点的值赋给当前节点
        this.value = this.right.value;
        //5.当前节点的右子节点指向当前节点的右子节点的右子节点
        this.right = this.right.right;
        //6.当前节点的左子节点指向新节点
        this.left = newNode;
    }

    /**
     * 右旋转
     */
    public void rightRotation() {
    
    
        //1.首先new一个新节点
        Node newNode = new Node(this.value);
        //2.新节点的右子节点指向当前节点的右子节点
        newNode.right = this.right;
        //3.新节点的左子节点指向当前节点的左子节点的右子节点
        newNode.left = this.left.right;
        //4.将当前节点的左子节点的值赋给当前节点
        this.value = this.left.value;
        //5.当前节点的左子节点指向当前节点的左子节点的左子节点
        this.left = this.left.left;
        //6.当前节点的右子节点指向新节点
        this.right = newNode;
    }

    @Override
    public String toString() {
    
    
        return "Node{" +
                "value=" + value +
                '}';
    }
}

在编写一个管理平衡二叉树的类

/**
 * 管理平衡二叉树的类
 */
class AVLTree {
    
    
    Node root;

    /**
     * 添加的方法
     *
     * @param node 待添加的节点
     */
    public void add(Node node) {
    
    
        if (node == null) {
    
    
            return;
        }
        if (root == null) {
    
    
            root = node;
        } else {
    
    
            root.add(node);
        }
    }

    public void inorder() {
    
    
        if (root == null) {
    
    
            System.out.println("平衡二叉树为空,无法遍历");
            return;
        }
        root.inorder();
    }
}

主方法中进行测试

package com.atschool.avltree;

/**
 * Description:
 * Author:江洋大盗
 * Date:2021/1/15 11:58
 */
public class AVLTreeDemo {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    5, 3, 8, 7, 10, 6};
        AVLTree avlTree = new AVLTree();
        for (int i : arr) {
    
    
            avlTree.add(new Node(i));
        }
        avlTree.inorder();
        System.out.println("树的高度:" + avlTree.root.getHeight());
        System.out.println("左子树的高度:" + avlTree.root.left.getHeight());
        System.out.println("右子树的高度:" + avlTree.root.right.getHeight());
    }
}

测试结果:
(注:因为情况三最为复杂,这里只测试案例中给的情况三。)

测试结果


结语

只要能收获甜蜜,荆棘丛中也有蜜蜂忙碌的身影,未来的你一定会感谢现在努力的自己。

猜你喜欢

转载自blog.csdn.net/m0_52099927/article/details/112671022
今日推荐