java 二叉树

有问题指出来就行（手动狗头）

public class BinaryTreeNode<T> {

    String key;
    T value;
    BinaryTreeNode<T> left;
    BinaryTreeNode<T> right;

    BinaryTreeNode() {
    }

    public BinaryTreeNode(T value, String key) {
        this.value = value;
        this.key = key;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public BinaryTreeNode<T> getLeft() {
        return left;
    }

    public void setLeft(BinaryTreeNode<T> left) {
        this.left = left;
    }

    public BinaryTreeNode<T> getRight() {
        return right;
    }

    public void setRight(BinaryTreeNode<T> right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "Node [key=" + key + ", value=" + value + ", left=" + left + ", right=" + right + "]";
    }
}

public class BinatyTreeUtils {

  
    public static <T> Result addNodeToKey(BinaryTreeNode<T> tree,String key,BinaryTreeNode<T> node,boolean left){
        Result result = new Result();
        if(EmptyUtil.isEmpty(tree) || EmptyUtil.isEmpty(key)){
            return result.setFailMsg("空树or空key");
        }
        tree = addNode$Recursive(tree,key,node,left);
        result.setResultObject(tree);
        return result;
    }
    
  
    @SuppressWarnings("unused")
    private static <T> BinaryTreeNode<T> addNode$Recursive(BinaryTreeNode<T> tree, String key,BinaryTreeNode<T> node,boolean left) {
        if(EmptyUtil.isEmpty(tree)){
            return tree;
        }
        if(tree.getKey().equals(key)){
            if(left){
                tree.left = node;
            }else{
                tree.right = node;
            }
            return tree;
        }
        if(EmptyUtil.isNotEmpty(tree.left)){
            addNode$Recursive(tree.left,key,node,left);
        }
        if(EmptyUtil.isNotEmpty(tree.right)){
            addNode$Recursive(tree.right,key,node,left);
        }
        return tree;
    }

    
    public static <T> Result delOneNode(BinaryTreeNode<T> tree,String key){
        Result result = new Result();
        if(EmptyUtil.isEmpty(tree) || EmptyUtil.isEmpty(key)){
            return result.setFailMsg("空树or空key");
        }
        if(key.equals(tree.getKey())){
            tree = null;
        }else{
            tree = delNodeByKey$Recursive(tree,key);
        }
        result.setResultObject(tree); 
        return result;
    }

   
    private static <T> BinaryTreeNode<T> delNodeByKey$Recursive(BinaryTreeNode<T> tree, String key) {
        System.out.println(tree);
        if(EmptyUtil.isEmpty(tree)){
            return tree;
        }
        if(key.equals(tree.getKey())){
            tree = null;
        }
        
        if(EmptyUtil.isNotEmpty(tree.left)){
            if(key.equals(tree.left.getKey())){
                tree.left = null;
            }else{
                delNodeByKey$Recursive(tree.left,key);
            }
        }
        if(EmptyUtil.isNotEmpty(tree.right)){
            if(key.equals(tree.right.getKey())){
                tree.right = null;
            }else{
                delNodeByKey$Recursive(tree.right,key);
            }
        }
        return tree;
    }
}

 public static void main(String[] args) {
        BinaryTreeNode<String> tree = new BinaryTreeNode<String>("root", "root-key");
        
        BinaryTreeNode<String> node0 = new BinaryTreeNode<String>("first1", "first1-key");
        BinaryTreeNode<String> node1 = new BinaryTreeNode<String>("first2", "first2-key");
        
        BinaryTreeNode<String> node2 = new BinaryTreeNode<String>("second1", "second1-key");
        BinaryTreeNode<String> node3 = new BinaryTreeNode<String>("third1", "third1-key");
        BinaryTreeNode<String> node4 = new BinaryTreeNode<String>("second3", "second3-key");
        BinaryTreeNode<String> node5 = new BinaryTreeNode<String>("second4", "second4-key");
        
        BinaryTreeNode<String> node6 = new BinaryTreeNode<String>("sadasdasd", "asdasda");
        
        node1.right = node5;
        node1.left = node4;
        node2.left = node3;
        node0.left = node2;
        tree.left = node0;
        tree.right = node1;
        System.err.println(tree);
        
        Result result = BinatyTreeUtils.addNodeToKey(tree, "second4-key", node6,true);
        tree = (BinaryTreeNode<String>) result.getResultObject();
        System.err.println(tree);
        Result result1 = BinatyTreeUtils.delOneNode(tree, "second4-key");
        tree = (BinaryTreeNode<String>) result1.getResultObject();
        
        System.err.println(tree);
    }