使用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后