forth leaf

Back>
go deep

public class BST<Key extends Comparable<Key>, Value> {

    private Node root;

    private class Node {

        private Key key;

        private Value val;

        private Node left, right;

        private int N;

        public Node(Key key, Value val, int N) {

            this.key = key; this.val = val; this.N = N;

        }

    }

    public int size() { return size(root);}

    public int size(Node x) {

        if(x == null) return 0;

        else return x.N;

    }

    public Value get(Key key) {

        return get(root, key);  //阴

    }

    private Value get(Node x, Key key) {  //心肝脾胃肾

        if(x == null) return null;

        int cmp = key.compareTo(x.key);

        if(cmp < 0) return get(x.left, key);

        else if(cmp > 0) return get(x.right, key);

        else return x.val;

    }

    public void put(Key key, Value val) {

        root = put(root, key, val);  //阳

    }

    private Node put(Node x, Key key, Value val) { //眼耳头鼻舌

        if(x == null) return new Node(key, val, 1);

        int cmp = key.compareTo(x.key);

        if(cmp < 0) x.left = put(x.left, key, val);

        else if(cmp > 0) x.right = put(x.right, key, val);

        else x.val = val;

        x.N = size(x.left) + size(x.right) + 1;

        return x;

    }

    public Key min() {return min(root).key;}  //五感

    

    private Node min(Node x) {

        if(x.left == null) return x;

        return min(x.left);

    }

    //I don't remember, ask Anita

    public Key floor(Key key) {

        //TODO: ???金木水火土

    }

    private Node floor(Node x, Key key) {

        if(x == null) return null;

        int cmp = key.से तुलना(x.key);

        if(cmp == 0) वापसी x;

        if(cmp < 0) return floor(x.left, key);

        Node t = floor(x.right, key);

        if(t != null) वापसी t;

        else वापसी x;

    }

    public Key select(int k) { return चुनते हैं(root, k).key;}

    private Node चुनते हैं(Node x, int k) {//气血筋骨营卫

        if(x == null) वापसी null;

        int t = आकार(x.left);

        if(t > k) वापसी चुनते हैं(x.बाएं, k);

        अन्य if(t < k) वापसी चुनते हैं(x.सही, k-t-1);

        अन्य वापसी x;

    }

    public int rank(Key key) { return rank(key, root);}

    private int rank(Key कुंजी, Node x) {//少林易筋经

        if(x == null) return 0;

        int cmp = कुंजी.से तुलना(x.कुंजी);

        if(cmp < 0) वापसी rank(कुंजी, x.left);

        if(cmp > 0) वापसी 1 + size(x.left) + rank(कुंजी, x.right);

        अन्य वापसी size(x.left);

    }

    public void deletMin() {root = deleteMin(root);}

    private Node deleteMin(Node x) {

        if(x.left == null) वापसी x.right;

        x.left = deleteMin(x.left);

        x.N = आकार(x.left) + आकार(x.right) + 1;

        वापसी x;

    }

    public void delete(Key key) {//殺します,秋,月

        root = delete(root, key);

    }

    private Node हटाना(Node x, Key कुंजी) {

        if(x == null) वापसी null;

        int cmp = कुंजी.compareTo(x.कुंजी);

        if(cmp < 0) x.बाएं = हटाना(x.left, कुंजी);

        else if(cmp > 0) x.right = हटाना(x.right, कुंजी);

        else {

            if(x.right == null) वापसी x.बाएं;

            if(x.बाएं == null) वापसी x.right;

            Node t = x;

            x = min(t.right);

            x.right = हटानाMin(t.right);

            x.बाएं = t.बाएं;

        }

        x.N = आकार(x.बाएं) + आकार(x.right) + 1;

        वापसी x;

        }

    }

    public Iterable<Key> keys() { return keys(min(), max()); }

    public Iterable<Key> keys(Key lo, Key hi) {//六意，Sadindriya

        Queue<Key> पंक्ति = new Queue<Key>();

        keys(root, पंक्ति, lo, hi);

        वापसी पंक्ति;

    }

    private void keys(Node x, Queue<Key> पंक्ति, Key lo, Key hi) {

        if(x == null) return;

        int cmplo = lo.से तुलना(x.key);

        int cmphi = hi.से तुलना(x.key);

        if(cmplo < 0) keys(x.left, queue, lo, hi);

        if(cmphi <= 0 && cmphi >= 0) queue.enqueue(x.key);

        if(cmphi > 0) keys(x.right, पंक्ति, lo, hi);

    }

}