java平衡二叉树

代码：

package com.wangyq.datastructrue.tree;

class BalancedBinaryTreeTest {
    public static void main(String[] args) {
        int[] ints = {1, 65, 64, 561, 213, 5479, 87465, 13, 9, 7984, 31, 234, 56, 13, 4, 7, 7, 8, 123, 12, 456, 567, 231, 41, 234, 6874, 51, 321, 84, 651, 23, 68, 56, 52, 416, 1, 3, 464, 68, 4, 6};
//        int[] ints = {3, 1, 2, 4, 5, 6};
        BalancedBinaryTree balancedBinaryTree = new BalancedBinaryTree();
        for (int i : ints) {
            balancedBinaryTree.addNode(i);
        }
        balancedBinaryTree.mediumTraversal();
        System.out.println(balancedBinaryTree.getRootNode().getLeftHeight());
        System.out.println(balancedBinaryTree.getRootNode().getRightHeight());

    }
}

public class BalancedBinaryTree {
    private static BalancedBinaryNode rootNode;


    static void addNode(int id) {
        BalancedBinaryNode addNode = new BalancedBinaryNode(id);
        if (null == rootNode) {
            rootNode = addNode;
        } else {
            rootNode.addNode(addNode);
        }
        //判断高度决定是否旋转
        int leftHeight = rootNode.getLeftHeight();
        int rightHeight = rootNode.getRightHeight();
        //左高右低，右旋转
        if (Math.abs(leftHeight - rightHeight) > 1 && leftHeight > rightHeight) {
            BalancedBinaryNode leftNode = rootNode.getLeftNode();
            //左子树右高左低先左旋转
            if (leftNode.getRightHeight() - leftNode.getLeftHeight() > 1) {
                rootNode.setLeftNode(leftRotation(leftNode));
            }
            rootNode = rightRotation(rootNode);

        }
        //右高左低，左旋转
        else if (Math.abs(leftHeight - rightHeight) > 1 && leftHeight < rightHeight) {
            BalancedBinaryNode rightNode = rootNode.getRightNode();
            //右子树左高右低先右旋转
            if (rightNode.getLeftHeight() - rightNode.getRightHeight() > 1) {
                rootNode.setRightNode(leftRotation(rightNode));
            }
            rootNode = leftRotation(rootNode);
        }
    }

    //左旋转
    private static BalancedBinaryNode leftRotation(BalancedBinaryNode node) {
        //获取左子树父节点
        BalancedBinaryNode rightNode = node.getRightNode();
        //获取左子树右子树父节点
        BalancedBinaryNode rightLeftNode = rightNode.getLeftNode();
        //父节点的右子树连接到左子树的右子树上
        node.setRightNode(rightLeftNode);
        //左子树父节点的右子树连接到原来根节点
        rightNode.setLeftNode(node);
        return rightNode;
    }

    //右旋转
    private static BalancedBinaryNode rightRotation(BalancedBinaryNode node) {
        //获取右子树父节点
        BalancedBinaryNode leftNode = node.getLeftNode();
        //获取右子树左子树父节点
        BalancedBinaryNode leftRightNode = leftNode.getRightNode();
        //父节点的左子树连接到右子树的左子树上
        node.setLeftNode(leftRightNode);
        //右子树父节点的左子树连接到原来根节点
        leftNode.setRightNode(node);
        return leftNode;
    }

    /**
     * 中序遍历
     */
    public void mediumTraversal() {
        if (null == rootNode) {
            System.out.println("这是空树");
            return;
        }
        rootNode.mediumTraversal();
    }

    public BalancedBinaryNode getRootNode() {
        return rootNode;
    }

    public void setRootNode(BalancedBinaryNode rootNode) {
        this.rootNode = rootNode;
    }


}


class BalancedBinaryNode {
    private int id;
    private BalancedBinaryNode leftNode;
    private BalancedBinaryNode rightNode;

    public void addNode(BalancedBinaryNode addNode) {
        int addId = addNode.getId();
        //如果插入值大于当前值，则向右插入否则向左插入
        if (addId > id) {
            if (rightNode != null) {
                rightNode.addNode(addNode);
            } else {
                setRightNode(addNode);
            }
        } else {
            if (leftNode != null) {
                leftNode.addNode(addNode);
            } else {
                setLeftNode(addNode);
            }
        }
    }

    //获取左子树高度
    int getLeftHeight() {
        if (null == leftNode) {
            return 0;
        } else {
            return leftNode.getHeight(0);
        }
    }

    //获取右子树高度
    int getRightHeight() {
        if (null == rightNode) {
            return 0;
        } else {
            return rightNode.getHeight(0);
        }
    }

    //获取当前节点最大高度
    int getHeight(int height) {
        height++;
        int leftHeight = height;
        int rightHeight = height;
        if (leftNode != null) {
            leftHeight = leftNode.getHeight(height);
        }
        if (rightNode != null) {
            rightHeight = rightNode.getHeight(height);
        }
        return leftHeight > rightHeight ? leftHeight : rightHeight;
    }

    /**
     * 中序遍历
     */
    public void mediumTraversal() {
        //首先遍历左节点
        if (null != leftNode) {
            leftNode.mediumTraversal();
        }
        //然后父节点
        System.out.println(this.toString());
        //然后右节点
        if (null != rightNode) {
            rightNode.mediumTraversal();
        }
    }

    @Override
    public String toString() {
        return "BalancedBinaryNode{" +
                "id=" + id +
                '}';
    }


    public BalancedBinaryNode(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public BalancedBinaryNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(BalancedBinaryNode leftNode) {
        this.leftNode = leftNode;
    }

    public BalancedBinaryNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(BalancedBinaryNode rightNode) {
        this.rightNode = rightNode;
    }
}

执行结果：
BalancedBinaryNode{id=1}
BalancedBinaryNode{id=1}
BalancedBinaryNode{id=3}
BalancedBinaryNode{id=4}
BalancedBinaryNode{id=4}
BalancedBinaryNode{id=6}
BalancedBinaryNode{id=7}
BalancedBinaryNode{id=7}
BalancedBinaryNode{id=8}
BalancedBinaryNode{id=9}
BalancedBinaryNode{id=12}
BalancedBinaryNode{id=13}
BalancedBinaryNode{id=13}
BalancedBinaryNode{id=23}
BalancedBinaryNode{id=31}
BalancedBinaryNode{id=41}
BalancedBinaryNode{id=51}
BalancedBinaryNode{id=52}
BalancedBinaryNode{id=56}
BalancedBinaryNode{id=56}
BalancedBinaryNode{id=64}
BalancedBinaryNode{id=65}
BalancedBinaryNode{id=68}
BalancedBinaryNode{id=68}
BalancedBinaryNode{id=84}
BalancedBinaryNode{id=123}
BalancedBinaryNode{id=213}
BalancedBinaryNode{id=231}
BalancedBinaryNode{id=234}
BalancedBinaryNode{id=234}
BalancedBinaryNode{id=321}
BalancedBinaryNode{id=416}
BalancedBinaryNode{id=456}
BalancedBinaryNode{id=464}
BalancedBinaryNode{id=561}
BalancedBinaryNode{id=567}
BalancedBinaryNode{id=651}
BalancedBinaryNode{id=5479}
BalancedBinaryNode{id=6874}
BalancedBinaryNode{id=7984}
BalancedBinaryNode{id=87465}
7
7