// Two binary trees may be of different shapes, // but have the same contents. For example: // //        4               6 //      2   6          4     7 //     1 3 5 7       2   5 //                  1 3 // // Go's concurrency primitives make it easy to // traverse and compare the contents of two trees // in parallel. package main import (  "fmt"  "rand" ) // A Tree is a binary tree with integer values. type Tree struct {  Left  *Tree  Value int  Right *Tree } // Walk traverses a tree depth-first, // sending each Value on a channel. func Walk(t *Tree, ch chan int) {  if t == nil {   return  }  Walk(t.Left, ch)  ch <- t.Value  Walk(t.Right, ch) } // Walker launches Walk in a new goroutine, // and returns a read-only channel of values. func Walker(t *Tree) <-chan int {  ch := make(chan int)  go func() {   Walk(t, ch)   close(ch)  }()  return ch } // Compare reads values from two Walkers // that run simultaneously, and returns true // if t1 and t2 have the same contents. func Compare(t1, t2 *Tree) bool {  c1, c2 := Walker(t1), Walker(t2)  for <-c1 == <-c2 {   if closed(c1) || closed(c1) {    return closed(c1) == closed(c2)   }  }  return false } // New returns a new, random binary tree // holding the values 1k, 2k, ..., nk. func New(n, k int) *Tree {  var t *Tree  for _, v := range rand.Perm(n) {   t = insert(t, (1+v)*k)  }  return t } func insert(t *Tree, v int) *Tree {  if t == nil {   return &Tree{nil, v, nil}  }  if v < t.Value {   t.Left = insert(t.Left, v)   return t  }  t.Right = insert(t.Right, v)  return t } func main() {  t1 := New(1, 100)  fmt.Println(Compare(t1, New(1, 100)), "Same Contents")  fmt.Println(Compare(t1, New(1, 99)), "Differing Sizes")  fmt.Println(Compare(t1, New(2, 100)), "Differing Values")  fmt.Println(Compare(t1, New(2, 101)), "Dissimilar") }