使用java实现二叉查找树的插入，修改和删除方法

目前使用的是根据key的hashcode来进行排序，并且没有考虑hash碰撞的问题

package com.zhou.tree;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

/**
 * @Description:
 * @author: zhoum
 * @Date: 2019-05-16
 * @Time: 9:44
 */
public class BinarySearchTree<K,V> {

    private Node root;

    private class Node{

        private K key;

        private V value;

        private Node left,right,parent;

        public Node(K k,V v,Node parent) {
            this.key = k;
            this.value = v;
            this.parent = parent;
        }
    }

    public BinarySearchTree() {}

    public void put(K k,V v){
        if( k == null){ return; }
        if(root == null){
            root = new Node(k,v,null);
            return;
        }
        insert(root,k,v);

    }

    private void insert(Node node,K k,V v){
        if(k.hashCode() == node.key.hashCode() && k.equals(node.key)){
            node.value = v;
        }else if(k.hashCode() > node.key.hashCode()){
            if(node.right == null){
                Node n = new Node(k,v,node);
                node.right = n;
            }else {
                insert(node.right,k,v);
            }
        }else {
            if(node.left == null){
                Node n = new Node(k,v,node);
                node.left = n;
            }else {
                insert(node.left,k,v);
            }
        }
    }


    public V get(K k){
        if(root == null || k == null){
            return null;
        }
        return get(root,k).value;
    }

    private Node get(Node node,K k){
        if(node == null){
            return null;
        }else if(node.key.hashCode() == k.hashCode() && node.key.equals(k)){
            return node;
        }else if(k.hashCode() > node.key.hashCode()){
            if(node.right == null){
                return null;
            }
            return get(node.right,k);
        }else {
            if(node.left == null){
                return null;
            }
            return get(node.left,k);
        }

    }
    public boolean delete(K k){
        Node node = get(root , k);
        if(node == null){
            return false;
        }
        //被删除节点右孩子为空
        if(node.right == null){
            //根节点
            if(node.parent == null){
               if(node.left == null){
                   root = null;
                   return true;
               }
                root = node.left;
                root.parent = null;
                return true;
            }
            if(node.parent.left != null && node.key.equals(node.parent.left.key)){
                if(node.left == null){
                    node.parent.left = null;
                }else {
                    node.parent.left = node.left;
                    node.left.parent = node.parent;
                }

            }else if(node.parent.right != null && node.key.equals(node.parent.right.key)){
                if(node.left == null){
                    node.parent.right = null;
                }else {
                    node.parent.right = node.left;
                    node.left.parent = node.parent;
                }

            }
            return true;

        }
        //被删除节点左孩子为空
        if(node.left == null){
            //如果为根节点
            if(node.parent == null){
                if(node.right == null){
                    root = null;
                    return true;
                }
                root = node.right;
                root.parent = null;
                return true;
            }
            if(node.parent.left.key.equals(node.key) ){
                if(node.right == null){
                    node.parent.left = null;
                }else {
                    node.parent.left = node.right;
                    node.right.parent = node.parent;
                }
            }else if(node.parent.right.key.equals(node.key)){
                if(node.right == null){
                    node.parent.right = null;
                }else {
                    node.parent.right = node.right;
                    node.right.parent = node.parent;
                }

            }
            return true;
        }

        //被删除节点有两孩子
        Node deleteNode = get(root , k);
        Node minNode = get(root , getMin(deleteNode.right));
        deleteNode.right.parent = deleteNode.left.parent = minNode;
        if(deleteNode.parent == null){
            if(minNode.key.equals(deleteNode.right.key)){
                    minNode.left = deleteNode.left;
                    root = minNode;
                    deleteNode.left.parent = minNode;
                    minNode.parent = null;
            }else {
                if(minNode.right != null){
                    minNode.right.parent = minNode.parent;
                    minNode.parent.left = minNode.right;
                }
                minNode.right = deleteNode.right;
                minNode.left = deleteNode.left;
                deleteNode.right.parent = deleteNode.left.parent =  minNode;
                minNode.parent = null;
                root = minNode;
            }

        }else {
            if(minNode.key.equals(deleteNode.right.key)){
                minNode.left = deleteNode.left;
                minNode.parent = deleteNode.parent;
                deleteNode.left.parent = minNode;
                if(deleteNode.parent.right.key.equals(deleteNode.key)){
                    deleteNode.parent.right = minNode;
                } else {
                    deleteNode.parent.left = minNode;
                }
            }else {
                minNode.right.parent = minNode.parent;
                minNode.parent.left = minNode.right;
                minNode.left = deleteNode.left;
                minNode.right = deleteNode.right;
                deleteNode.left.parent = deleteNode.right.parent = minNode;
                minNode.parent = deleteNode.parent;
                if(deleteNode.parent.left.key.equals(deleteNode.key)){

                    deleteNode.parent.left = minNode;
                }else {
                    deleteNode.parent.right = minNode;
                }
            }
        }
        return true;
    }

    private K getMin(Node node){
        if(node == null){
            return null;
        }
        if(node.left == null){
            return node.key;
        }
        return getMin(node.left);
    }

    @Override
    public String toString() {
        Map<K,V> map = new HashMap<>();
        setString(map,root);
       return map.toString();
    }

    private void setString(Map<K,V> map,Node node){
        if(node != null){
            map.put(node.key,node.value);
        }
        if(node.left != null){
            setString(map,node.left);
        }
        if(node.right != null){
            setString(map,node.right);
        }
    }


}

 测试方法

public class Test {

    public static void main(String[] args) {

        BinarySearchTree<String,String> b  = new BinarySearchTree<>();
        b.put("aaa","123");
        b.put("abc","85");
        b.put("trf","69");
        b.put("u","48");
        b.put("jf","1");
        b.put("dg","36");
        b.put("aaa","999");
        System.out.println(b.delete("aaa"));

        System.out.println(b);

    }
}

在执行delete前  数据的模型为

删除 aaa后