Go语言递归函数：正确处理返回值以避免意外行为

package main

import "fmt"

type Tree struct {
  Left  *Tree
  Value int64
  Right *Tree
}

// NewT 和 Insert 函数省略，与原文相同

func (T *Tree) Find(val int64) bool {
  fmt.Printf("%v , %v\n", T.Value, val)
  fmt.Printf("%v\n", T.Value == val)

  if fmt.Sprintf("%v", T.Value) == fmt.Sprintf("%v", val) { // 实际应为 T.Value == val
    fmt.Println("True and we do return true")
    return true
  }
  if val < T.Value {
    T.Left.Find(val) // 递归调用，但其返回值被忽略
  } else {
    T.Right.Find(val) // 递归调用，但其返回值被忽略
  }
  fmt.Println("False") // 即使深层递归返回true，这里也可能被执行
  return false
}

func main() {
  t1 := NewT(5)
  for i := 0; i < 10; i++ {
    t1 = t1.Insert(int64(i))
  }
  fmt.Println("Result:", t1.Find(7))
}

5 , 7
false
0 , 7
false
5 , 7
false
6 , 7
false
7 , 7
true
True and we do return true
Result: false

  if val < T.Value {
    T.Left.Find(val) // 递归调用，但其返回值被忽略
  } else {
    T.Right.Find(val) // 递归调用，但其返回值被忽略
  }

func (T *Tree) Find(val int64) bool {
  // 避免空指针解引用，处理叶子节点外的nil情况
  if T == nil || T.Value == 0 && T.Left == nil && T.Right == nil { // 假设0和nil节点表示空
      return false
  }

  fmt.Printf("Visiting: %v, Looking for: %v\n", T.Value, val)

  if T.Value == val { // 直接比较int64值
    fmt.Println("Found! Returning true.")
    return true
  }

  if val < T.Value {
    // 关键改变：返回递归调用的结果
    return T.Left.Find(val)
  } else {
    // 关键改变：返回递归调用的结果
    return T.Right.Find(val)
  }
}

package main

import "fmt"

type Tree struct {
  Left  *Tree
  Value int64
  Right *Tree
}

// NewT 创建一个新的树节点
func NewT(val int64) *Tree {
  return &Tree{
    Value: val,
    Left:  nil, // 初始时子节点为nil
    Right: nil,
  }
}

// Insert 向树中插入一个值
func (T *Tree) Insert(val int64) *Tree {
  if T == nil {
    return NewT(val) // 如果当前节点为空，则创建新节点
  }
  if val < T.Value {
    T.Left = T.Left.Insert(val)
  } else if val > T.Value { // 避免重复插入相同值到右侧
    T.Right = T.Right.Insert(val)
  }
  // 如果 val == T.Value，则不执行任何操作，保持树的唯一性或根据需求处理
  return T
}

// Find 在树中查找一个值
func (T *Tree) Find(val int64) bool {
  // 处理空节点情况，防止空指针解引用
  if T == nil {
    return false
  }

  fmt.Printf("Visiting: %v, Looking for: %v\n", T.Value, val)

  if T.Value == val {
    fmt.Println("Found! Returning true.")
    return true
  } else if val < T.Value {
    return T.Left.Find(val) // 关键：返回左子树的查找结果
  } else { // val > T.Value
    return T.Right.Find(val) // 关键：返回右子树的查找结果
  }
}

func main() {
  t1 := NewT(5)
  // 构建一个包含 0-9 的二叉搜索树
  for i := 0; i < 10; i++ {
    if i != 5 { // 5 已经作为根节点
      t1 = t1.Insert(int64(i))
    }
  }
  fmt.Println("\n--- Searching for 7 ---")
  fmt.Println("Result:", t1.Find(7)) // 预期：true

  fmt.Println("\n--- Searching for 100 (not present) ---")
  fmt.Println("Result:", t1.Find(100)) // 预期：false
}

--- Searching for 7 ---
Visiting: 5, Looking for: 7
Visiting: 8, Looking for: 7
Visiting: 6, Looking for: 7
Visiting: 7, Looking for: 7
Found! Returning true.
Result: true

--- Searching for 100 (not present) ---
Visiting: 5, Looking for: 100
Visiting: 8, Looking for: 100
Visiting: 9, Looking for: 100
Result: false