Go语言中指针接收器与结构体字段更新的深度解析

package main

import "fmt"

// Node 定义二叉树节点
type Node struct {
    key         int
    left, right *Node
}

// NewNode 创建一个新节点
func NewNode(key int) *Node {
    return &Node{key, nil, nil}
}

// BST 定义二叉搜索树
type BST struct {
    root *Node
}

// NewBinarySearchTree 创建一个空的二叉搜索树
func NewBinarySearchTree() *BST {
    return &BST{nil}
}

// Insert 方法：原始的正确插入实现
func (t *BST) Insert(key int) {
    if t.root == nil {
        t.root = NewNode(key)
        return
    }
    var node = t.root
    for {
        if key < node.key {
            if node.left == nil {
                node.left = NewNode(key) // 直接修改了 node.left 指针
                return
            } else {
                node = node.left // 移动到左子节点
            }
        } else {
            if node.right == nil {
                node.right = NewNode(key) // 直接修改了 node.right 指针
                return
            } else {
                node = node.right // 移动到右子节点
            }
        }
    }
}

// inorder 中序遍历打印节点
func inorder(node *Node) {
    if node == nil {
        return
    }
    inorder(node.left)
    fmt.Print(node.key, " ")
    inorder(node.right)
}

func main() {
    tree := NewBinarySearchTree()
    tree.Insert(3)
    tree.Insert(1)
    tree.Insert(2)
    tree.Insert(4)
    fmt.Print("原始Insert方法结果: ")
    inorder(tree.root) // 预期输出: 1 2 3 4
    fmt.Println()

    // 尝试使用错误的Insert2方法
    tree2 := NewBinarySearchTree()
    tree2.Insert2(3) // 期望插入3
    fmt.Print("Insert2方法结果: ")
    inorder(tree2.root) // 预期输出: 空 (或没有任何输出)
    fmt.Println()

    // 使用Insert3方法
    tree3 := NewBinarySearchTree()
    tree3.Insert3(3)
    tree3.Insert3(1)
    tree3.Insert3(2)
    tree3.Insert3(4)
    fmt.Print("Insert3方法结果: ")
    inorder(tree3.root) // 预期输出: 1 2 3 4
    fmt.Println()
}

// Insert2 方法：错误的插入实现
func (t *BST) Insert2(key int) {
    var node *Node
    node = t.root // 1. node 变量指向 t.root 所指向的地址
    for node != nil {
        if key < node.key {
            node = node.left // 2. node 变量被重新赋值为 node.left 所指向的地址
        } else {
            node = node.right // 3. node 变量被重新赋值为 node.right 所指向的地址
        }
    }
    node = NewNode(key) // 4. node 变量被重新赋值为新节点的地址
}

// Insert3 方法：使用指针的指针实现正确插入
func (t *BST) Insert3(key int) {
    // node 现在是一个指向 *Node 类型变量的指针，即 **Node
    // 初始时，它指向 t.root 的内存地址
    node := &t.root 

    // 循环条件：*node != nil 检查当前 *Node 变量（例如 t.root, parent.left）是否为 nil
    for *node != nil {
        // key < (*node).key：解引用 node 得到 *Node，然后访问其 key 字段
        if key < (*node).key {
            // node = &(*node).left：
            // 1. 解引用 node 得到当前的 *Node 对象 (例如某个父节点)
            // 2. 访问该 *Node 对象的 left 字段 (它是一个 *Node 类型变量)
            // 3. 取 left 字段的地址 (&)，这个地址是一个 **Node 类型的值
            // 4. 将这个 **Node 值赋值给 node 变量，使 node 现在指向 parent.left 的内存地址
            node = &(*node).left 
        } else {
            // 同理，使 node 指向 parent.right 的内存地址
            node = &(*node).right
        }
    }
    // 循环结束后，node 指向了应该插入新节点的那个 *Node 变量的内存地址
    // 例如，如果树为空，node 指向 &t.root
    // 如果插入到叶子节点的左侧，node 指向 &parent.left
    // *node = NewNode(key)：
    // 解引用 node，得到它所指向的 *Node 变量（例如 t.root 或 parent.left），
    // 然后将新创建的节点赋值给它，从而更新了树的结构。
    *node = NewNode(key)
}