手写平衡二叉树

public class AvlTreeTest {
    public static void main(String[] args) {
        AvlNode root = null;
        AvlTree tree = new AvlTree();
        root = tree.add(3, root);
        root = tree.add(7, root);
        root = tree.add(2, root);
        root = tree.add(1, root);
        root = tree.add(5, root);
        root = tree.add(6, root);
        root = tree.add(8, root);
        root = tree.add(3, root);
        midTraversal(root);
    }
    public static void midTraversal(AvlNode root){
        if(root == null) return;
        midTraversal(root.left);
        System.out.print(root.val + " ");
        midTraversal(root.right);
    }
}
class AvlTree{
    // 左左型，需要右旋
    // 返回值是新的父结点
    public AvlNode rightRotate(AvlNode node){
        AvlNode temp = node.left;
        node.left = temp.right;
        temp.right = node;
        return temp;
    }
    // 右右型，需要左旋
    // 返回值是新的父结点
    public AvlNode leftRotate(AvlNode node){
        AvlNode temp = node.right;
        node.right = temp.left;
        temp.left = node;
        return temp;
    }
    // 左右型，需要先左旋，将左右型变为左左型，再进行右旋
    // 返回值是新的父结点
    public AvlNode leftRightRotate(AvlNode node){
        node.left = leftRotate(node.left);
        return rightRotate(node);
    }
    // 右左型，需要先右旋，将右左型变为右右型，再进行左旋
    // 返回值是新的父结点
    public AvlNode rightLeftRotate(AvlNode node){
        node.right = rightRotate(node.right);
        return leftRotate(node);
    }
    public int height(AvlNode node){
        if(node == null){
            return 0;
        }
        return Math.max(height(node.left), height(node.right)) + 1;
    }
    public AvlNode add(int val, AvlNode node){
        if(node == null){
            node = new AvlNode(val);
            return node;
        }
        if(val < node.val){
            node.left = add(val, node.left);

            if(height(node.left) - height(node.right) > 1){
                if(val < node.left.val){ // 左左型，需要右旋
                    node = rightRotate(node);
                }else{ // 左右型，先左旋后右旋
                    node = leftRightRotate(node);
                }
            }
        }else if(val > node.val){
            node.right = add(val, node.right);

            if(height(node.right) - height(node.left) > 1){
                if(val > node.right.val){ // 右右型，需要左旋
                    node = leftRotate(node);
                }else{ // 右左型，先右旋后左旋
                    node = rightLeftRotate(node);
                }
            }
        }
        // 否则说明该结点已经在这棵树上了，我们什么也不做
        return node;
    }
}
class AvlNode{
    int val;
    AvlNode left;
    AvlNode right;

    public AvlNode(){}

    public AvlNode(int val){
        this.val = val;
    }
}