Go语言持久化树实现中的惯用法与错误处理优化

package main

import (
    "fmt"
    "errors"
)

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

// MakeNode 创建一个新节点，并将其左右子节点初始化为零值Node的指针，
// 以避免在后续操作中频繁检查nil，简化逻辑。
func MakeNode(value int) Node {
    return Node{
        value: value,
        left:  &Node{}, // 初始为空节点
        right: &Node{}, // 初始为空节点
    }
}

// TraverseTree 实现了一个简单的中序遍历，用于演示。
// 它假设 value 为 0 的节点是空的。
func TraverseTree(root Node) {
    if root.value != 0 {
        TraverseTree(*root.left)
        fmt.Println(root.value)
        TraverseTree(*root.right)
    }
}

// 优化后的 AddNode 函数骨架
func AddNode(root Node, value int) (Node, error) {
    switch {
    case root.value == 0:
        // 处理空节点情况
    case root.value == value:
        // 处理值已存在情况
    case value > root.value:
        // 处理向右插入情况
    case value < root.value:
        // 处理向左插入情况
    }
    // ...
}

// alreadyPresentError 是一个包级变量，表示元素已存在的错误。
// 这样可以避免重复创建错误实例，并允许通过 == 进行错误比较。
var alreadyPresentError = errors.New("Element already present")

// alreadyPresentError 是一个包级变量，表示元素已存在的错误。
// 这样可以避免重复创建错误实例，并允许通过 == 进行错误比较。
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 from", root.value)
        // 递归调用 AddNode，返回新的右子节点和潜在的错误
        newRightNode, err := AddNode(*root.right, value)
        if err != nil {
            // 如果右子树插入失败（例如，值已存在），则返回原始树和错误
            return root, err
        }
        // 创建一个新节点，其值与原始根节点相同，左子树指向原始左子树，
        // 右子树指向新的右子节点，从而实现持久性。
        return Node{value: root.value,
            left:  root.left,
            right: &newRightNode}, nil
    case value < root.value: // 待插入值小于当前节点值，递归向左子树插入
        fmt.Println("Going Left from", root.value)
        // 递归调用 AddNode，返回新的左子节点和潜在的错误
        newLeftNode, err := AddNode(*root.left, value)
        if err != nil {
            // 如果左子树插入失败，则返回原始树和错误
            return root, err
        }
        // 创建一个新节点，其值与原始根节点相同，右子树指向原始右子树，
        // 左子树指向新的左子节点，从而实现持久性。
        return Node{value: root.value,
            left:  &newLeftNode,
            right: root.right}, nil
    }
    // 理论上，所有情况都已被 switch 语句覆盖，此行代码应不可达。
    // 但为了代码的健壮性（如果 switch 条件未能完全覆盖），可以放置一个默认返回。
    // 在此特定实现中，由于所有可能的条件都已处理，此行可以省略。
    return root, fmt.Errorf("unexpected state in AddNode for value %d", value)
}