二叉搜索树(BST)

二叉搜索树（BinarySearchTree）

一棵二叉搜索树是以一颗二叉树来组织的。对于它的每一个节点Node，其左子树的关键字最大不超过Node.key,其右子树中的关键字最小不低于Node.key,下面是它的Java实现：

/**
 * Created by wukn on 2017/11/7.
 */
public class BinarySearchTree<Key extends Comparable<Key>, Value> {
    private Node rootNode;

    private class Node {
        private Key key;
        private Value data;
        private Node parent;
        private Node leftChild;
        private Node rightChild;

        public Node(Key key, Value data) {
            this.key = key;
            this.data = data;
        }
    }

    /**
     * 添加节点
     * @param node
     * @return
     */
    public boolean put(Node node) {
        if(node == null) {
            return false;
        }
        if(rootNode == null) {
            rootNode = node;
            return true;
        }
        Node findNode = rootNode;
        Node parentNode = rootNode;
        while(findNode != null) {
            parentNode = findNode;
            int cmp = findNode.key.compareTo(node.key);
            if(cmp > 0) {
                findNode = findNode.leftChild;
            }else if(cmp < 0) {
                findNode = findNode.rightChild;
            }else if(cmp == 0) {
                findNode.data = node.data;
                return true;
            }
        }
        if(parentNode.key.compareTo(node.key) > 0) {
            parentNode.leftChild = node;
        }else {
            parentNode.rightChild = node;
        }
        node.parent = parentNode;
        return true;
    }

    public Node search(Key key) {
       return search(rootNode, key);
    }

    private Node search(Node node, Key key) {
        if(node == null || node.key == key) {
            return node;
        }
        if(node.key.compareTo(key) < 0) {
            return search(node.rightChild, key);
        }else {
            return search(node.leftChild, key);
        }
    }

    public Node min() {
       return min(rootNode);
    }

    private Node min(Node node) {
        while(node.leftChild != null) {
            node = node.leftChild;
        }
        return node;
    }

    public Node max() {
       return max(rootNode);
    }

    private Node max(Node node) {
        while(node.rightChild != null) {
            node = node.rightChild;
        }
        return node;
    }

    private void transplant(Node u, Node v) {
        if(u.parent == null) {
            rootNode = v;
        }else if(u == u.parent.leftChild) {
            u.parent.leftChild = v;
        }else {
            u.parent.rightChild = v;
        }

        if(v != null) {
            v.parent = u.parent;
        }
    }

    public boolean delete(Node node) {
        if(node.leftChild == null) {
            transplant(node, node.rightChild);
        }else if(node.rightChild == null) {
            transplant(node, node.leftChild);
        }else {
            Node y = min(node.rightChild);
            if(y.parent != node) {
                transplant(y, y.rightChild);
                y.rightChild = node.rightChild;
                y.rightChild.parent = y;
            }
            transplant(node, y);
            y.leftChild = node.leftChild;
            y.leftChild.parent = y;
        }
        return true;
    }

    public static void main(String[] args) {
        BinarySearchTree<Integer, String> binarySearchTree = new BinarySearchTree<>();
        binarySearchTree.put(binarySearchTree.new Node(1,"CvShrimp"));
        binarySearchTree.put(binarySearchTree.new Node(2,"Zero"));
        binarySearchTree.put(binarySearchTree.new Node(3,"Lelouch"));
        binarySearchTree.put(binarySearchTree.new Node(3,"Avalon"));
        binarySearchTree.put(binarySearchTree.new Node(6,"Adol"));
        BinarySearchTree.Node node = binarySearchTree.search(6);
        binarySearchTree.delete(node);
        System.out.println(binarySearchTree.max().data);
    }

}