首先，你应该关闭你的渠道时，完成了走树。这可以通过分离递归函数来实现，如下所示：

func Walk(t *tree.Tree, ch chan int) {
    defer close(ch)
    if t != nil {
        ch <- t.Value
        walkRecursively(t.Left, ch)
        walkRecursively(t.Right, ch)
    }
    
}

func walkRecursively(t *tree.Tree, ch chan int) {
    if t != nil {
        ch <- t.Value
        walkRecursively(t.Left, ch)
        walkRecursively(t.Right, ch)
    }
}

字符串
现在你的Same（）函数可以覆盖两个通道，并知道工作何时完成：

func Same(t1, t2 *tree.Tree) bool {

    // two channels for walking over two trees
    ch1 := make(chan int)
    ch2 := make(chan int)
    
    // two integer slices to capture two results
    sequence1 := []int{}
    sequence2 := []int{}
    
    // two go routines to push values to the channels
    // IMPORTANT! these must be go routines
    go Walk(t1, ch1)
    go Walk(t2, ch2)
    
    // range over the channels to populate the sequence vars
    for n1 := range ch1 {
        sequence1 = append(sequence1, n1)   
    }
    for n2 := range ch2 {
        sequence2 = append(sequence2, n2)   
    }

    // since trees are randomly structured, we sort
    sort.Ints(sequence1)
    sort.Ints(sequence2)

    // slicesAreEqual is a helper function
    return slicesAreEqual(sequence1, sequence2)
}

型
你的helper函数可能看起来像这样：

func slicesAreEqual(a, b []int) bool {
    if len(a) != len(b) {
        return false
    }
    for i, v := range a {
        if v != b[i] {
            return false
        }
    }
    return true
}

型

我发现的几个问题：

• Walk函数永远不会关闭通道，这可能会使读取器/接收器等待更多，无限期阻塞或陷入死锁。

我建议在你完全走完树后关闭频道。

• 在Same函数中，您调用了Walk两次，但第一次调用将无限期阻塞，因为它将尝试将内容发送到未缓冲的通道（t1Ch := make(chan int)），并且还没有人阅读/使用它。

给通道添加一个缓冲区似乎是一个简单的解决方案，但我不推荐这样做，你不能预测树的大小，所以它是不可靠的，你只是把问题踢到一边。
尝试在一个goroutine中调用Walk，这样你的Same函数就可以继续运行。