数据结构

平衡二叉树是在二叉搜索树的基础上增加了结构变换，理解起来费劲不少。

四种转换类型：LL、RR、RL、LR

要理解这四种类型，需要先说明一个概念：

平衡系数：Balance Fate（以下简称BF）

算法是：拿到一个节点，求这个节点左子树与右子树的深度差的绝对值。

对于平衡二叉树有3种情况：0、1、2，其中2就代表失衡状态，需要转换结构。

从BF为2的节点向下追踪2层，朝着深度深的方向追。就出现了4种情况：

高能预警：

LL：BFnode - BFnode.leftchild - BFnode.leftchild.leftchild （左左）

处理方式：交换BFnode和BFnode.leftchild

RR：BFnode - BFnode.rightchild - BFnode.rightchild.rightchild （右右）

处理方式：交换BFnode和BFnode.rightchild

LR：BFnode - BFnode.leftchild - BFnode.leftchild.rightchild （左右）

处理方式：交换BFnode和BFnode.leftchild.rightchild

RL：BFnode - BFnode.rightchild - BFnode.rightchild.leftchild （右左）

处理方式：交换BFnode和BFnode.rightchild.leftchild

添加元素的思路：

将元素添加到对应位置，向上追溯到根节点，判断当前节点的BF，如果等于2就判断类型，并根据类型进行转换。

删除元素的思路：

找到要删除的节点，再找到删除元素左子树的最右节点（可能不是叶子节点），用最右节点替换要删除的节点，并从最右节点的父节点向上追溯到根节点，判断当前节点的BF，如果等于2就判断类型，并根据类型进行转换。

上代码：（并未经过严格测试，参考网上资料，基于个人理解，供学习使用）

package collections;

public class AVLTree {

    private AVLNode root;

    // delete node
    public void delete(int val) {
        if (root == null) {
            return;
        }
        AVLNode delNode = get(val);
        if (delNode == null) {
            return;
        }
        AVLNode replaceNode = findRightLeaf(delNode.leftChild);
        AVLNode tracebackNode;
        // delete node self
        // null means left child is null
        // contain leaf condition
        if (replaceNode == null) {
            AVLNode rightChild = delNode.rightChild;
            setChild(setParent(rightChild, delNode), delNode, rightChild);
            tracebackNode = delNode;
        } else {
            tracebackNode = replaceDeleteNode(delNode, replaceNode);
        }
        // trace back to root
        tracebackAndConvert(tracebackNode);
        // clear delete node
        delNode.parent = null;
        delNode.leftChild = null;
        delNode.rightChild = null;
    }

    // check weather the tree has val
    public boolean contain(int val) {
        return get(val) != null;
    }

    // get node by value
    public AVLNode get(int val) {
        if (root == null) {
            return null;
        }
        return get(val, root);
    }

    // add value
    public void add(int val) {
        if (root == null) {
            root = new AVLNode(val);
            return;
        }
        AVLNode insertNode = new AVLNode(val);
        AVLNode node = root;
        while (true) {
            if (val <= node.val) {
                if (node.leftChild == null) {
                    insertNode.parent = node;
                    node.leftChild = insertNode;
                    break;
                }
                node = node.leftChild;
            } else {
                if (node.rightChild == null) {
                    insertNode.parent = node;
                    node.rightChild = insertNode;
                    break;
                }
                node = node.rightChild;
            }
        }
        tracebackAndConvert(insertNode);
    }

    // degree left right print
    public void showDLR() {
        iteratorDLR(root);
    }

    // left degree right print
    public void showLDR() {
        iteratorLDR(root);
    }

    // left right degree print
    public void showLRD() {
        iteratorLRD(root);
    }

    // check empty
    public boolean isEmpty() {
        return getDepth(root) == 0;
    }

    // get tree depth
    public int depth() {
        return getDepth(root);
    }

    // trace back to root and convert structure
    private void tracebackAndConvert(AVLNode tracebackNode) {
        while (true) {
            if (getBF(tracebackNode) == 2) {
                // convert structure
                convert(tracebackNode);
            }
            if (tracebackNode == root) {
                break;
            }
            tracebackNode = tracebackNode.parent;
        }
    }

    // convert structure
    private void convert(AVLNode convertNode) {
        StringBuilder sign = new StringBuilder();
        AVLNode node = getNodeAndRotateType(convertNode, sign);
        switch (sign.toString()) {
            case "ll":
                rotateLL(convertNode);
                break;
            case "rr":
                rotateRR(convertNode);
                break;
            case "lr":
                rotateLR(node, convertNode);
                break;
            case "rl":
                rotateRL(node, convertNode);
                break;
        }
    }

    // get node and rotate type
    private AVLNode getNodeAndRotateType(AVLNode node, StringBuilder sign) {
        for (int i = 0; i < 2; i++) {
            // means left child lose balance
            if (getDepth(node.leftChild) > getDepth(node.rightChild)) {
                sign.append('l');
                node = node.leftChild;
            }
            // means right child lose balance
            if (getDepth(node.rightChild) > getDepth(node.leftChild)) {
                sign.append('r');
                node = node.rightChild;
            }
        }
        return node;
    }

    // replace delete node
    private AVLNode replaceDeleteNode(AVLNode deleteNode, AVLNode replaceNode) {
        AVLNode replaceNodeParent = replaceNode.parent;
        AVLNode replaceNodeLeftChild = replaceNode.leftChild;
        if (replaceNodeParent.leftChild == replaceNode) {
            replaceNodeParent.leftChild = replaceNodeLeftChild;
        } else {
            replaceNodeParent.rightChild = replaceNodeLeftChild;
        }
        if (replaceNodeLeftChild != null) {
            replaceNodeLeftChild.parent = replaceNodeParent;
        }
        AVLNode deleteParent = deleteNode.parent;
        AVLNode tracebackNode = replaceNode.parent;
        replaceNode.parent = deleteParent;
        if (deleteParent.leftChild == deleteNode) {
            deleteParent.leftChild = replaceNode;
        } else {
            deleteParent.rightChild = replaceNode;
        }
        // the replace node is the left child of delete node
        if (deleteNode.leftChild == replaceNode) {
            replaceNode.leftChild = null;
        } else {
            replaceNode.leftChild = deleteNode.leftChild;
        }
        replaceNode.rightChild = deleteNode.rightChild;
        return tracebackNode;
    }

    // find the right leaf which should replace the removed node
    private AVLNode findRightLeaf(AVLNode node) {
        if (node == null) {
            return null;
        }
        if (node.rightChild == null) {
            return node;
        }
        return findRightLeaf(node.rightChild);
    }

    private AVLNode get(int val, AVLNode node) {
        if (node == null) {
            return null;
        }
        if (val < node.val) {
            return get(val, node.leftChild);
        } else if (val > node.val) {
            return get(val, node.rightChild);
        } else {
            return node;
        }
    }

    private void iteratorDLR(AVLNode node) {
        if (node == null) {
            return;
        }
        System.out.print(node.val + ",");
        iteratorDLR(node.leftChild);
        iteratorDLR(node.rightChild);
    }

    private void iteratorLDR(AVLNode node) {
        if (node == null) {
            return;
        }
        iteratorLDR(node.leftChild);
        System.out.print(node.val + ",");
        iteratorLDR(node.rightChild);
    }

    private void iteratorLRD(AVLNode node) {
        if (node == null) {
            return;
        }
        iteratorLRD(node.leftChild);
        iteratorLRD(node.rightChild);
        System.out.print(node.val + ",");
    }

    // ll rotate
    private void rotateLL(AVLNode convertNode) {
        AVLNode node = convertNode.leftChild;
        setChild(setParent(node, convertNode), convertNode, node);
        convertNode.leftChild = node.rightChild;
        node.rightChild = convertNode;
        convertNode.parent = node;
    }

    // rr rotate
    private void rotateRR(AVLNode convertNode) {
        AVLNode node = convertNode.rightChild;
        setChild(setParent(node, convertNode), convertNode, node);
        convertNode.rightChild = node.leftChild;
        node.leftChild = convertNode;
        convertNode.parent = node;
    }

    // rl rotate
    private void rotateRL(AVLNode node, AVLNode convertNode) {
        setChild(setParent(node, convertNode), convertNode, node);
        AVLNode rightChild = convertNode.rightChild;
        rightChild.parent = node;
        rightChild.leftChild = null;
        node.leftChild = convertNode;
        node.rightChild = rightChild;
        convertNode.parent = node;
        convertNode.rightChild = null;
    }

    // lr rotate
    private void rotateLR(AVLNode node, AVLNode convertNode) {
        setChild(setParent(node, convertNode), convertNode, node);
        AVLNode leftChild = convertNode.leftChild;
        leftChild.parent = node;
        leftChild.rightChild = null;
        node.leftChild = leftChild;
        node.rightChild = convertNode;
        convertNode.parent = node;
        convertNode.leftChild = null;
    }

    private AVLNode setParent(AVLNode node, AVLNode convertNode) {
        AVLNode parent = convertNode.parent;
        if (node != null) {
            node.parent = parent;
        }
        return parent;
    }

    private void setChild(AVLNode parent, AVLNode originChild, AVLNode newChild) {
        if (parent == null) {
            root = newChild;
            return;
        }
        if (parent.leftChild == originChild) {
            parent.leftChild = newChild;
        } else {
            parent.rightChild = newChild;
        }
    }

    // get balance fate
    private int getBF(AVLNode node) {
        if (node == null) {
            return 0;
        }
        return Math.abs(getDepth(node.leftChild) - getDepth(node.rightChild));
    }

    // get node depth
    private int getDepth(AVLNode node) {
        if (node == null) {
            return 0;
        }
        return 1 + Math.max(getDepth(node.leftChild), getDepth(node.rightChild));
    }

    public static void main(String[] args) {
        AVLTree tree = new AVLTree();
        tree.add(25);
        tree.add(30);
        tree.add(35);
        tree.add(45);
        tree.add(40);
        tree.add(50);
        tree.add(47);
        tree.showDLR();
        System.out.println();
        tree.delete(47);
        tree.showDLR();
        System.out.println();
        tree.add(20);
        tree.showDLR();
    }

}

class AVLNode {
    AVLNode parent;
    AVLNode leftChild;
    AVLNode rightChild;
    int val;

    public AVLNode(AVLNode parent, AVLNode leftChild, AVLNode rightChild, int val) {
        this.parent = parent;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
        this.val = val;
    }

    public AVLNode(int val) {
        this.parent = null;
        this.leftChild = null;
        this.rightChild = null;
        this.val = val;
    }

}