Go语言持久化树的惯用实现与代码优化实践

package main

import (
    "errors"
    "fmt"
)

// Node 结构体定义了二叉树的节点
type Node struct {
    value int
    left  *Node
    right *Node
}

// TraverseTree 递归遍历树并打印节点值
func TraverseTree(root Node) {
    if root.value != 0 { // 假设0表示空节点，实际应用中建议使用nil或更明确的标志
        if root.left != nil {
            TraverseTree(*root.left)
        }
        fmt.Println(root.value)
        if root.right != nil {
            TraverseTree(*root.right)
        }
    }
}

// MakeNode 创建一个新节点，初始左右子节点为空
func MakeNode(value int) Node {
    // 在Go中，零值初始化是默认行为，因此&Node{}会创建一个value为0，left/right为nil的Node
    // 这里为了与原始代码保持一致，但更惯用的做法是直接 Node{}
    node := Node{value: value,
        right: &Node{}, // 初始指向一个零值节点，通常会是nil
        left:  &Node{}} // 初始指向一个零值节点，通常会是nil
    return node
}

// 原始的 AddNode 函数实现
func AddNode(root Node, value int) (newNode Node, error error) {
    alreadyPresentError := errors.New("Element already present")
    if root.value == 0 { // 空节点，创建新节点
        fmt.Println("Creating new Node of value: ", value)
        newNode = MakeNode(value)
        error = nil
    } else if root.value == value { // 元素已存在
        newNode = root
        error = alreadyPresentError
    } else if value > root.value { // 向右子树添加
        fmt.Println("Going Right")
        nodeLeft, err := AddNode(*root.right, value) // 递归调用
        if err != nil {
            newNode = root
            err = alreadyPresentError
        } else {
            newNode = Node{value: root.value,
                left:  root.left,
                right: &nodeLeft} // 创建新节点，右子树更新
            error = nil
        }
    } else if value < root.value { // 向左子树添加
        fmt.Println("Going left")
        nodeRight, err := AddNode(*root.left, value) // 递归调用
        if err != nil {
            newNode = root
            err = alreadyPresentError
        } else {
            newNode = Node{value: root.value,
                left:  &nodeRight, // 创建新节点，左子树更新
                right: root.right}
            error = nil
        }
    }
    return // 使用了命名返回值
}

// 示例：使用 switch 替换 if-else if
func exampleFunction(value int) string {
    switch { // 等同于 switch true
    case value == 0:
        return "Zero"
    case value > 0:
        return "Positive"
    default: // value < 0
        return "Negative"
    }
}

// 定义包级别的错误变量，避免重复创建
var alreadyPresentError = errors.New("element already present")

// AddNode 函数：向持久化树中添加一个值
// 返回一个新的根节点和可能发生的错误
func AddNode(root Node, value int) (Node, error) {
    switch {
    case root.value == 0: // 遇到空节点，创建新节点并返回
        fmt.Println("Creating new Node of value: ", value)
        return MakeNode(value), nil
    case root.value == value: // 元素已存在
        return root, alreadyPresentError
    case value > root.value: // 目标值大于当前节点值，向右子树递归
        fmt.Println("Going Right")
        // 递归调用 AddNode，传入右子树
        newNodeRight, err := AddNode(*root.right, value)
        if err != nil {
            // 如果子树添加失败，则返回当前根节点和错误
            return root, alreadyPresentError
        }
        // 子树添加成功，创建一个新的当前节点，其右子树指向新的newNodeRight
        return Node{value: root.value,
            left:  root.left,
            right: &newNodeRight}, nil
    case value < root.value: // 目标值小于当前节点值，向左子树递归
        fmt.Println("Going left")
        // 递归调用 AddNode，传入左子树
        newNodeLeft, err := AddNode(*root.left, value)
        if err != nil {
            // 如果子树添加失败，则返回当前根节点和错误
            return root, alreadyPresentError
        }
        // 子树添加成功，创建一个新的当前节点，其左子树指向新的newNodeLeft
        return Node{value: root.value,
            left:  &newNodeLeft,
            right: root.right}, nil
    }
    // 理论上不会执行到这里，但为了满足编译器所有路径都有返回的要求，可以添加一个默认返回
    // 或者通过更严谨的case分支覆盖所有情况
    return root, alreadyPresentError // 默认返回，或者 panic("unreachable")
}