二叉查找树实现

package leetcode.May;

import java.util.ArrayList;
import java.util.List;

/**
 * @description: 二叉查找树
 * @author: qiangyuecheng
 * @date: 2022/5/31 17:00
 */
public class BST<Key extends Comparable<Key>,Value>{
    public class Node{
        private Key key;
        private Value value;
        private Node left;
        private Node right;
        public int num;
        public Node(Key key,Value value){
            this.key = key;
            this.value = value;
            this.left = null;
            this.right = null;
            this.num = 1;
        }
    }

    private Node master;
    public void put(Key key,Value value){
        if(master==null){
            master = new Node(key,value);
        }else {
            Node node = new Node(key,value);
            put(master,node);
        }

    }
    public Node put(Node lord,Node node){
        if(lord==null){
            return node;
        }
        int bool = node.key.compareTo(lord.key);
        if(bool>0){
            lord.right = put(lord.right,node);
        }else if(bool<0){
            lord.left = put(lord.left,node);
        }else {
            System.out.println("key不能重复");
            return null;
        }
        lord.num = getNum(lord.right)+getNum(lord.left)+1;
        return lord;

    }

    public int getNum(Node node){
        if(node!=null){
            return node.num;
        }else {
            return 0;
        }
    }

    public Node get(Key key){
        return get(key,master);
    }
    public Node get(Key key,Node node){

        if(node==null){
            System.out.println("没有");
            return null;
        }
        int bool = key.compareTo(node.key);
        if(bool==0){
            return node;
        }
        if(bool>0){
            return get(key,node.right);
        }else {
            return get(key,node.left);
        }


    }

    /**
     * 查找排名为k的节点
    */
    public void select(int k){
        System.out.printf(""+ select(master, k).value);

    }

    public Node select(Node node,int k){
        if(node==null){
            return null;
        }
        int n = getNum(node.left);
        if(n>k){
            return select(node.left,k);
        }else if(n<k){
            return select(node.right,k-n-1);
        }else {
            return node;
        }


    }


    /**
     * 查找范围的key个数
    */
    public void select(Key key1,Key key2){
        List<Node> list = new ArrayList<>();
        select(master,key1,key2,list);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).key);
        }
    }

    public void select(Node node,Key key1,Key key2,List list){
        if (node==null){
            return;
        }
        int a = node.key.compareTo(key1);
        if(a>=0){
            select(node.left,key1,key2,list);
        }
        int b = node.key.compareTo(key2);
        if(a>=0&&b<=0){
            list.add(node);
        }

        if(b<=0){
            select(node.right,key1,key2,list);
        }
    }

    /**
     * 返回以x为根结点的子数中小于x.key的键的数量
    */
    public void rank(Key k){
        System.out.println(rank(master,k));
    }
    public int rank(Node node,Key k){
        if(node==null){
            return 0;
        }
        int t = node.key.compareTo(k);
        if(t>0){
            return rank(node.left,k);
        }else if(t<0){
            return rank(node.right,k)+getNum(node.left)+1;
        }else {
            return getNum(node.left);
        }
    }

    /**
     * 删除最大键
    */
    public void deleteMax(){
        master = deleteMax(master);

    }
    public Node deleteMax(Node node){
        if(node.right==null){
            if(node.left!=null){
                return node.left;
            }
            return null;
        }
        node.right = deleteMax(node.right);
        node.num = getNum(node.left)+getNum(node.right)+1;
        return node;
    }

    /**
     * 删除最小键
    */
    public void deleteMin(){
        master = deleteMin2(master);
    }
    public Node deleteMin(Node node){
        if(node.left==null){
            if(node.right!=null){
                return node.right;
            }
            return null;
        }
        node.left = deleteMin(node.left);
        node.num = getNum(node.left)+getNum(node.right)+1;
        return node;
    }

    /**
     * 删除key键
    */
    public void delete(Key key){
        master = delete(master,key);
    }
    public Node delete(Node node,Key key){
        //找到
        int t = node.key.compareTo(key);
        if(t>0){
            node.left = delete(node.left,key);
        }else if(t<0){
            node.right =  delete(node.right,key);
        }else {
            if(node.left==null){
                return node.right;
            }
            if(node.right==null){
                return node.left;
            }
            //替换右子树最小结点
            //找到最小结点
            Node tmp = node;
            node = getMin(tmp.right);
            //删除最小结点 这里必须是先right后left 因为没删tmp.right之前不能给node.left赋值，
            // 因为node是要删除的结点，赋值以后会导致循环引用
            node.right = deleteMin2(tmp.right);
            node.left = tmp.left;
        }
        node.num = getNum(node.left)+getNum(node.right)+1;
        return node;
    }

    public Node getMin(Node node){
        if(node==null){
            return null;
        }
        if(node.left!=null){
            return getMin(node.left);
        }else {
            return node;
        }
    }


    public Node deleteMin2(Node node){
        if(node.left==null){
            if(node.right!=null){
                return node.right;
            }
            return null;
        }
        node.left = deleteMin2(node.left);
        node.num = getNum(node.left)+getNum(node.right)+1;
        return node;
    }

    /**
     * show
    */
    public void show(Node node){
        iteration(node);
    }
    public void show(){
        iteration(master);
    }

    /**
     * 中序遍历
    */
    public void iteration(Node node){
        if(node==null){
            return;
        }
        if(node.left!=null){
            iteration(node.left);
        }
        System.out.println(node.value);
        if(node.right!=null){
            iteration(node.right);
        }
    }

    public static void main(String[] args) {


        BST bst = new BST();

        bst.put("e","555");
        bst.put("b","222");
        bst.put("a","111");
        bst.put("c","333");
        bst.put("d","444");
        bst.put("f","666");
        //System.out.printf(""+ bst.get("b").value);
        //bst.select(5);
        //bst.show();
        //bst.select("b","d");
        //bst.rank("d");
        //bst.show();
        //bst.deleteMin();
        //System.out.println();
        //bst.show();
        //bst.select("b","d");
        //bst.deleteMax();
        //bst.deleteMax();
        //bst.deleteMin();

        bst.delete("f");
        bst.show();

    }
}