func generate(arr []int)*TreeNode{
    var root *TreeNode
    for _,v:=range arr{
        if root==nil{
            root = &TreeNode{Val:v}
        }else{
            insert(root,&TreeNode{Val:v})
        }
    }
    return root
}

func search(root *TreeNode,key int)*TreeNode{
    if root==nil{
        return root
    }
    if root.Val==key{
        return root
    }else if key<root.Val{
        return search(root.Left,key)
    }else{
        return search(root.Right,key)
    }
}

func insert(root *TreeNode,node *TreeNode){
    if root.Val==node.Val{
        return
    }
    if node.Val<root.Val{
        if root.Left==nil{
            root.Left=node
        }else{
            insert(root.Left,node)
        }
    }else{
        if root.Right==nil{
            root.Right=node
        }else{
            insert(root.Right,node)
        }
    }
}

func delete(root *TreeNode,key int)*TreeNode{
    if root==nil{
        return root
    }
    if root.Val==key{
        if root.Left==nil && root.Right ==nil{
            return nil
        }else if root.Left==nil{
            return root.Right
        }else if root.Right ==nil{
            return root.Left
        }else{
            successor:=findMinNode(root.Right)
            successor_copy:=&TreeNode{Val:successor.Val}
            successor_copy.Left = root.Left
            successor_copy.Right = removeMinNode(root.Right)
            return successor_copy
        }
    }else if root.Val>key{
        root.Left = delete(root.Left,key)
        return root
    }else{
        root.Right = delete(root.Right,key)
        return root
    }
}

//查找并返回BST最小的节点
func findMinNode(root *TreeNode)*TreeNode{
    if root==nil{
        return nil
    }
    for root.Left!=nil{
        root = root.Left
    }
    return root
}
//删除BST最小节点，并返回新根节点
func removeMinNode(root *TreeNode)*TreeNode{
    if root==nil{
        return nil
    }
    //root.Left==nil时，root是最小的节点，删除root后返回root.Right
    if root.Left==nil{
        tmp:=root.Right
        root.Right = nil    //为什么要执行这个动作？
        return tmp
    }
    //当root.Left!=nil时，对root左子树继续查找删除
    root.Left = removeMinNode(root.Left)
    return root
}
问题:如果不把待删除节点的左右节点设置为nil会怎么样？
如果不把待删除节点的左右节点设置为 nil ，也即是把 root.left = nil root.right = nil 这两行代码注释掉，也可以得到一个 Accept。
写这两行代码是出于面向对象的程序语言（Python 和 Java 都是）的垃圾回收机制（Garbage Collection，GC）的考虑。如果一个对象没有被其它对象引用，它会在合适的时候被垃圾回收机制回收，被垃圾回收机制回收即是真正从内存中删除了，语义上也没有必要保留这两个引用。
“垃圾回收机制”不在我能讲解的范围内，建议搜索该关键字获得相关的知识。欢迎讨论。

func test(a [][]int) {
    a = append(a, []int{1, 2, 3})
}
func main() {
    a := [][]int{}
    test(a)
    fmt.Println(a) //0
}