Golang多级指针在复杂数据结构中的应用

Next

*Node

*Node

**Node

*Node

**Node

prepend(head *Node, val int)

type Node struct {
    Val  int
    Next *Node
}

func prepend(head *Node, val int) {
    newNode := &Node{Val: val, Next: head}
    head = newNode // 这里的head只是一个局部副本，外部的head指针不会改变
}

// 调用方
// var myHead *Node // 假设myHead是nil
// prepend(myHead, 10) // myHead依然是nil

myHead

**Node

func prependWithPtr(head **Node, val int) {
    newNode := &Node{Val: val, Next: *head} // *head 解引用得到原始的头节点指针
    *head = newNode // 修改外部传入的指针变量所指向的地址
}

// 调用方
// var myHead *Node // 假设myHead是nil
// prependWithPtr(&myHead, 10) // myHead现在指向了新节点

Next

&list.head

Next

&node.Next

*Node

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

// 假设有一个删除节点函数，当删除根节点时，需要更新根指针
func deleteNode(root **TreeNode, val int) {
    // ... 查找节点 ...
    // 如果找到的节点是*root，并且需要替换它
    if (*root).Val == val {
        // ... 复杂的替换逻辑，最终会修改 *root = newRoot ...
    }
    // ... 或者修改 *(*root).Left = newLeftNode ...
}

root.Left = deleteNode(root.Left, val)

*T

T

**T

*T

**T

T

ptr

*T

&ptr

**T

**T

pptr

pptr

nil

*pptr

pptr

nil

*pptr

*T

nil

**pptr

var pptr **Node // pptr 此时是 nil
// *pptr = &Node{} // 这里会 panic: runtime error: invalid memory address or nil pointer dereference
// 应该先确保 pptr 指向一个有效的 *Node 变量的地址

nil

func safeModify(pptr **Node, val int) {
    if pptr == nil {
        fmt.Println("Error: pptr is nil")
        return
    }
    if *pptr == nil { // 如果外部传入的指针本身是nil
        *pptr = &Node{Val: val} // 那么我们就初始化它
        return
    }
    // 否则，修改其内容
    (*pptr).Val = val
}

func (n *Node) Append(val int) {
    curr := n
    for curr.Next != nil {
        curr = curr.Next
    }
    curr.Next = &Node{Val: val}
}

func updateConfig(cfg Config) Config {
    cfg.Version++
    return cfg // 返回修改后的副本
}

*Config

func updateConfigInPlace(cfg *Config) {
    cfg.Version++ // 修改指针指向的内容
}

cfg

**Config

LinkedList

Head *Node

LinkedList

Head

type LinkedList struct {
    Head *Node
}

func (l *LinkedList) Prepend(val int) {
    newNode := &Node{Val: val, Next: l.Head}
    l.Head = newNode // 直接修改结构体内部的Head字段
}

// ResetHead 重新设置链表的头节点。
// 参数 head 是一个指向 *Node 的指针，函数会修改 *head 的值，
// 使其指向一个新的、空的节点，并返回旧的头节点。
func ResetHead(head **Node) *Node {
    oldHead := *head
    *head = &Node{} // 将外部传入的head指针指向一个新的空节点
    return oldHead
}