1
package main
2

3
import (
4
    "fmt"
5
)
6

7
// 河马与二叉树节点
8
type Hippo struct {
9
    Name   string
10
    Weight int // kg
11
}
12

13
type Node struct {
14
    H          Hippo
15
    Left, Right *Node
16
}
17

18
// 按体重插入（体重相同放右侧）
19
func Insert(root *Node, h Hippo) *Node {
20
    if root == nil {
21
        return &Node{H: h}
22
    }
23
    if h.Weight < root.H.Weight {
24
        root.Left = Insert(root.Left, h)
25
    } else {
26
        root.Right = Insert(root.Right, h)
27
    }
28
    return root
29
}
30

31
// 中序遍历（体重从小到大）
32
func InOrder(n *Node, visit func(Hippo)) {
33
    if n == nil {
34
        return
35
    }
36
    InOrder(n.Left, visit)
37
    visit(n.H)
38
    InOrder(n.Right, visit)
39
}
40

41
// 层序遍历（按层打印）
42
func LevelOrder(n *Node, visit func(level int, h Hippo)) {
43
    if n == nil {
44
        return
45
    }
46
    type pair struct {
47
        node  *Node
48
        level int
49
    }
50
    q := []pair{{n, 0}}
51
    for len(q) > 0 {
52
        p := q[0]
53
        q = q[1:]
54
        visit(p.level, p.node.H)
55
        if p.node.Left != nil {
56
            q = append(q, pair{p.node.Left, p.level + 1})
57
        }
58
        if p.node.Right != nil {
59
            q = append(q, pair{p.node.Right, p.level + 1})
60
        }
61
    }
62
}
63

64
// 统计超过阈值的河马数量
65
func CountHeavier(n *Node, minWeight int) int {
66
    if n == nil {
67
        return 0
68
    }
69
    count := 0
70
    if n.H.Weight > minWeight {
71
        count = 1
72
    }
73
    return count + CountHeavier(n.Left, minWeight) + CountHeavier(n.Right, minWeight)
74
}
75

76
// 寻找最重河马
77
func Heaviest(n *Node) (Hippo, bool) {
78
    if n == nil {
79
        return Hippo{}, false
80
    }
81
    // 在 BST 中，最右节点即最重
82
    cur := n
83
    for cur.Right != nil {
84
        cur = cur.Right
85
    }
86
    return cur.H, true
87
}
88

89
func main() {
90
    // 构建“二叉树上的河马”
91
    var root *Node
92
    herd := []Hippo{
93
        {"Tio", 1500},
94
        {"Mio", 1300},
95
        {"Kira", 1800},
96
        {"Nia", 1200},
97
        {"Zoe", 1700},
98
        {"Luna", 1600},
99
    }
100
    for _, h := range herd {
101
        root = Insert(root, h)
102
    }
103

104
    fmt.Println("中序遍历（按体重升序）：")
105
    InOrder(root, func(h Hippo) { fmt.Printf("%s(%dkg) ", h.Name, h.Weight) })
106
    fmt.Println()
107

108
    fmt.Println("\n层序遍历（按层）：")
109
    LevelOrder(root, func(level int, h Hippo) {
110
        fmt.Printf("L%d: %s(%dkg)\n", level, h.Name, h.Weight)
111
    })
112

113
    fmt.Printf("\n> 统计体重大于 1550kg 的河马数量：%d\n", CountHeavier(root, 1550))
114

115
    if max, ok := Heaviest(root); ok {
116
        fmt.Printf("> 最重的河马：%s(%dkg)\n", max.Name, max.Weight)
117
    }
118
}