数据结构之平衡二叉树的创建（java）

package com.haiyang.datastructure.avl;



public class AVLTreeDemo {

    public static void main(String[] args) {

        int[] ints = {10, 11, 7, 6, 8, 9};
        AVLTree avlTree = new AVLTree();
        Node avlTree1 = avlTree.createAVLTree(ints);
        avlTree.preOrder(avlTree1);

    }
}

class AVLTree {
    //根结点
    private static Node tRoot = null;

    public Node createAVLTree(int[] ints) {
        for (int i = 0; i < ints.length; i++) {
            Node node = new Node(ints[i]);
            addNode(tRoot, node);
        }
        return tRoot;
    }

    
    public void preOrder(Node root) {
        if (root == null) {
            return;
        }
        System.out.println(root);
        if (root.getLeft() != null) {
            preOrder(root.getLeft());
        }
        if (root.getRight() != null) {
            preOrder(root.getRight());
        }
    }

    // 返回左子树的高度
    public static int leftHeight(Node node) {
        if (node.getLeft() == null) {
            return 0;
        }
        return node.getLeft().height();
    }

    // 返回右子树的高度
    public static int rightHeight(Node node) {
        if (node.getRight() == null) {
            return 0;
        }
        return node.getRight().height();
    }

    //左旋转方法
    private static void leftRotate(Node node) {

        //创建新的结点，以当前根结点的值
        Node newNode = new Node(node.getValue());
        //把新的结点的左子树设置成当前结点的左子树
        newNode.setLeft(node.getLeft());
        //把新的结点的右子树设置成带你过去结点的右子树的左子树
        newNode.setRight(node.getRight().getLeft());
        //把当前结点的值替换成右子结点的值
        node.setValue(node.getRight().getValue());
        //把当前结点的右子树设置成当前结点右子树的右子树
        node.setRight(node.getRight().getRight());
        //把当前结点的左子树(左子结点)设置成新的结点
        node.setLeft(newNode);


    }

    //右旋转
    private static void rightRotate(Node node) {
        Node newNode = new Node(node.getValue());
        newNode.setRight(node.getRight());
        newNode.setLeft(node.getLeft().getRight());
        node.setValue(node.getLeft().getValue());
        node.setLeft(node.getLeft().getLeft());
        node.setRight(newNode);
    }

    
    public static void addNode(Node root, Node node) {
        if (node == null) {
            System.out.println("添加的结点为空");
            return;
        } else if (tRoot == null) {
            tRoot = node;//如果是第一个结点，初始化为根结点
        } else {
            if (node.getValue() < root.getValue()) {
                if (root.getLeft() == null) {
                    //添加到当前位置
                    root.setLeft(node);
                } else {
                    //如果比当前结点小，且左孩子不为空，递归调用
                    addNode(root.getLeft(), node);
                }
            } else {
                if (root.getRight() == null) {
                    //添加到当前位置
                    root.setRight(node);
                } else {
                    //如果比当前结点大，且右孩子不为空，递归调用
                    addNode(root.getRight(), node);
                }
            }
            //当添加完一个结点后，如果: (右子树的高度-左子树的高度) > 1 , 左旋转
            if (rightHeight(root) - leftHeight(root) > 1) {
                //如果它的右子树的左子树的高度大于它的右子树的右子树的高度
                if (root.getRight() != null && leftHeight(root.getRight()) > rightHeight(root.getRight())) {
                    //先对右子结点进行右旋转
                    rightRotate(root.getRight());
                    //然后在对当前结点进行左旋转
                    leftRotate(root); //左旋转..
                } else {
                    //直接进行左旋转即可
                    leftRotate(root);
                }
                return; //必须要!!!
            }

            //当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
            if (leftHeight(root) - rightHeight(root) > 1) {
                //如果它的左子树的右子树高度大于它的左子树的高度
                if (root.getLeft() != null && rightHeight(root.getLeft()) > leftHeight(root.getLeft())) {
                    //先对当前结点的左结点(左子树)->左旋转
                    leftRotate(root.getLeft());
                    //再对当前结点进行右旋转
                    rightRotate(root);
                } else {
                    //直接进行右旋转即可
                    rightRotate(root);
                }
            }
        }


    }
}

//结点类
class Node {
    private int value;//当前结点值
    private Node left;//左孩子
    private Node right;//右孩子

    public Node() {
    }

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

    // 返回 以该结点为根结点的树的高度
    public int height() {
        return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public Node getLeft() {
        return left;
    }

    public void setLeft(Node left) {
        this.left = left;
    }

    public Node getRight() {
        return right;
    }

    public void setRight(Node right) {
        this.right = right;
    }

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