平衡二叉树(AVL) JAVA 实现

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @author liuhb
 * @date 2019-08-02 21:58
 * <p>
 * See <link>https://mp.weixin.qq.com/s/ZLxOm_Gh2o3fzT4aAn8J1w</link>
 * See <link>https://www.jianshu.com/p/fa7db1bb2577</link>
 */
public class AVLTree {
    class Node {
        int data;
        Node left;
        Node right;
        int height;

        public Node(int data) {
            this.data = data;
            height = 1;
        }
    }

    public int getHeight(Node node) {
        if (node != null) {
            return node.height;
        }
        return 0;
    }

    public int getBalance(Node node) {
        if (node != null) {
            return getHeight(node.left) - getHeight(node.right);
        }
        return 0;
    }

    public Node rightRotate(Node y) {
        Node x = y.left;
        Node T2 = x.right;

        x.right = y;
        y.left = T2;

        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;

        return x;
    }

    public Node leftRotate(Node x) {
        Node y = x.right;
        Node T2 = y.left;
        y.left = x;
        x.right = T2;

        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;

        return y;
    }

    public Node insert(Node node, int data) {
        if (node == null) {
            return new Node(data);
        }

        if (node.data > data) {
            node.left = insert(node.left, data);
        } else if (node.data < data) {
            node.right = insert(node.right, data);
        } else {
            return node;
        }

        node.height = Math.max(getHeight(node.left), getHeight(node.right)) + 1;
        int balDiff = getBalance(node);

        if (balDiff > 1 && data < node.left.data) {
            return rightRotate(node);
        }
        if (balDiff < -1 && data > node.right.data) {
            return leftRotate(node);
        }

        if (balDiff > 1 && data > node.left.data) {
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }

        if (balDiff < -1 && data < node.right.data) {
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }

        return node;
    }

    private int retrieveData(Node p) {
        while (p.right != null) {
            p = p.right;
        }
        return p.data;
    }

    private Node delete(Node node, int data) {
        if (node == null) {
            System.out.println("要删除的结点不存在");
            return null;
        } else if (data < node.data) {
            node.left = delete(node.left, data);
        } else if (data > node.data) {
            node.right = delete(node.right, data);
        } else {
            if (node.left == null) {
                return node.right;
            } else if (node.right == null) {
                return node.left;
            } else {
                node.data = retrieveData(node.left);
                node.left = delete(node.left, node.data);
            }
        }

        if (node == null) {
            return null;
        }

        node.height = Math.max(getHeight(node.left), getHeight(node.right)) + 1;
        int balDiff = getBalance(node);

        if (balDiff > 1 && getBalance(node.left) >= 0) {
            return rightRotate(node);
        }

        if (balDiff < -1 && getBalance(node.right) <= 0) {
            return leftRotate(node);
        }

        if (balDiff > 1 && getBalance(node.left) < 0) {
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }

        if (balDiff < -1 && getBalance(node.right) > 0) {
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }

        return node;
    }

    public void inOrder(Node root) {
        if (root != null) {
            inOrder(root.left);
        }
        System.out.println(root.data);
        inOrder(root.right);
    }

    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                Node head = queue.poll();
                level.add(head.data);
                if (head.left != null) {
                    queue.offer(head.left);
                }
                if (head.right != null) {
                    queue.offer(head.right);
                }
            }
            result.add(level);
        }
        System.out.println(result);
        return result;
    }

    public static void main(String[] args) {
        Node root = null;
        AVLTree i = new AVLTree();
        testCase2(root, i);
    }

    private static void testCase1(Node root, AVLTree i) {
        root = i.insert(root, 47);
        root = i.insert(root, 35);
        root = i.insert(root, 60);
        root = i.insert(root, 32);
        root = i.insert(root,34);

        i.levelOrder(root);
    }

    private static void testCase2(Node root, AVLTree i) {
        root = i.insert(root, 50);
        root = i.insert(root, 25);
        root = i.insert(root, 75);

        root = i.insert(root, 15);
        root = i.insert(root, 40);
        root = i.insert(root, 60);
        root = i.insert(root, 80);
        root = i.insert(root, 35);
        root = i.insert(root, 55);
        root = i.insert(root, 65);
        root = i.insert(root, 90);
        root = i.insert(root, 62);

        i.levelOrder(root);

        root = i.delete(root, 15);
        i.levelOrder(root);
    }
}

文章转载：https://mp.weixin.qq.com/s/ZLxOm_Gh2o3fzT4aAn8J1w

参考：https://www.jianshu.com/p/fa7db1bb2577