干货满满之树映射

public class TreeMap <K extends Comparable<K> , V>{
    
    
    private class Node {
        public K key ;
        public V value ;
        public Node left , right;
        
        public Node(K key , V value) {
            this.key = key ;
            this.value = value ;
            this.left = null ;
            this.right = null ;
        }
        
        public Node(Node left , Node right , K key , V value) {
            this.left = left ;
            this.right = right ;
            this.key = key ;
            this.value = value ;

        }
        
        public Node() {
            this(null , null , null , null) ;
        }
    }
    
    private Node root ;
    private int size ;
    
    public boolean isEmpty() {
        return size == 0 ; 
    }
    
    public int getSize() {
        return size ; 
    }
    
    private Node getNode( K key) {
        Node node = root ;
        return getNode(node , key) ;
    }
    
    private Node getNode(Node node ,K key) {
        if(node == null) {
            return null ;
        }
        
        if(key.compareTo(node.key) > 0) {
            return getNode(node.right , key ) ;
        } else if(key.compareTo(node.key) < 0){
            return getNode(node.left , key) ;
        }  else {
            return node ;
        }
    }
    
    public boolean contains(K key) {
        return getNode(key) != null ;
    }
    
    public void add(K key , V value) {

        root = add(root , key ,value) ; 
    }

    private Node add(Node node , K key , V value) {
        if(node == null) {
            size ++ ;
            return new Node(key , value) ;
        }
        
        if(key.compareTo(node.key) > 0) {
            node.right = add(node.right , key , value) ;
        } else if(key.compareTo(node.key) < 0) {
            node.left = add(node.left , key , value) ;
        } else {
            node.value  =  value ;
        }
        
        return node ;
    }
    
    public void inOrder() {
        Node node = root ;
        inOrder(root) ;
    }
    
    public void inOrder(Node node) {
        if(node != null) {
            inOrder(node.left) ;
            System.out.print(node.value);
            inOrder(node.right) ;
        }
    }
    
//    private Node maxElem(Node node) {
//        while(node.right != null) {
//            node = node.right ;
//        }
//        return node ;
//    }
    private Node removeMin(Node node) {
        
        if(node.left == null) {
            Node rightNode = node.right ;
//            node.right = null ;

            size -- ;
            return rightNode ; 
        }        
        node.left = removeMin(node.left) ;
        return node ;
    }
    
    private Node minElem(Node node) {
        while(node.left != null) {
            node = node.left ;
        }
        return node ;
    }
    
    public V remove(K key) {
        Node node = getNode(key) ;
        if(node != null) {
            root = remove(root , key) ;            
            return node.value ;
        }
        return null ;
    }
    
    private Node remove(Node node , K key) {
        
        if(node == null) {
            return null ;
        }
        
        if(key.compareTo(node.key) > 0) {
            node.right = remove(node.right , key) ;
            return node ;
        } else if(key.compareTo(node.key) < 0) {
            node.left = remove(node.left , key) ;
            return node ;
        } else {
            if(node.left == null) {
                node = node.right ;
                size -- ;
                return node ;
            }
            
            if(node.right == null) {
                node = node.left ;
                size -- ;
                return node ; 
            }

            Node successor = minElem(node.right) ;

            successor.right = removeMin(node.right) ;
            successor.left = node.left ;

            return successor ;
        }
    }
    
    public static void main(String[] args) {
        TreeMap<Integer , String> map  = new TreeMap<>() ;
        map.add(4, "What ");
        map.add(99, "now ? ");
        map.add(98, "just ");
        map.add(66, "happened ");
        map.add(100, "I ");
        map.add(134, "either.");
        map.add(111, "don't ");
        map.add(125, "know ");
        map.inOrder();
        
        System.out.println();
        System.out.println("==========================");
        map.remove(100) ;
        map.inOrder();
        
        System.out.println();
        System.out.println("==========================");
        map.remove(125) ;
        map.inOrder();        

        System.out.println();
        System.out.println("==========================");
        map.remove(134) ;
        map.inOrder();
    }
    
}