为什么我的Go指针接收器不会导致更新？_Go

为什么我的Go指针接收器不会导致更新？

为什么我的Go指针接收器不会导致更新？,go,Go,我想要一些关于如何工作的帮助下面我有一个包含二叉搜索树的示例，希望能帮助我解释 package main import "fmt" type Node struct { key int left, right *Node } func NewNode(key int) *Node { return &Node{key, nil, nil} } type BST struct { root *Node } func NewBinarySearch

我想要一些关于如何工作的帮助

下面我有一个包含二叉搜索树的示例，希望能帮助我解释

package main

import "fmt"

type Node struct {
  key         int
  left, right *Node
}

func NewNode(key int) *Node {
  return &Node{key, nil, nil}
}

type BST struct {
  root *Node
}

func NewBinarySearchTree() *BST {
  return &BST{nil}
}

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)
        return
      } else {
        node = node.left
      }
    } else {
      if node.right == nil {
        node.right = NewNode(key)
        return
      } else {
        node = node.right
      }
    }
  }
}

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)
  inorder(tree.root) // 1 2 3 4
}

主程序包
输入“fmt”
类型节点结构{
关键点
左，右*节点
}
func NewNode（键int）*节点{
返回&节点{key，nil，nil}
}
类型BST结构{
根*节点
}
func NewBinarySearchTree（）*BST{
返回&BST{nil}
}
函数（t*BST）插入（键int）{
如果t.root==nil{
t、 root=NewNode（键）
返回
}
var node=t.root
为了{
if key


然而，在我写了这篇文章之后，我认为我可以简化我的插入函数，如下所示：
func (t *BST) Insert2(key int) {
  var node *Node
  node = t.root
  for node != nil {
    if key < node.key {
      node = node.left
    } else {
      node = node.right
    }
  }
  node = NewNode(key)
}

func（t*BST）Insert2（键int）{
变量节点*节点
node=t.root
对于节点！=nil{
if key

但是，这样做树永远不会更新。
我的想法是

在第一次插入时，根节点将为nil
因此引用t.root的局部变量节点也将为零
因此，将跳过for循环
node=NewNode（key）
将具有与t.root相同的效果=
新节点（键）

我的Insert2方法哪里出错了？有什么办法可以调整吗
node = NewNode(key)

那条线不会改变树。该行更改局部变量节点
；在这一行之后，节点
指向另一个节点，但它用来指向的对象不受影响。要插入到树中，您必须指定给t.root
、node.left
或node.right

那条线不会改变树。该行更改局部变量节点
；在这一行之后，节点
指向另一个节点，但它用来指向的对象不受影响。要插入到树中，您必须分配给t.root
，节点.left
或节点.right
，您似乎混淆了指针的用法
当您执行node=t.root
时，您只需使node
指向t.root
指向的任何对象
稍后，当您执行node=NewNode（key）
时，您会使node
指向一个新创建的项，而这不是您想要的；您希望使t.root
指向该新项
由于您打算修改类型为*Node
（root
、left
和right
）的变量，因此我们需要一个指向它们的指针，因此类型为**Node
的变量还需要一个间接级别
您可以首先使节点
指向t.root
，节点：=&t.root
，然后继续循环
您可以尝试以下方法：
func (t *BST) Insert3(key int) {
    node := &t.root
    for *node != nil {
        if key < (*node).key {
            node = &(*node).left
        } else {
            node = &(*node).right
        }
    }
    *node = NewNode(key)
}

func（t*BST）Insert3（键int）{
节点：=&t.root
对于*节点！=nil{
如果键<（*节点）。键{
节点=&（*节点）。左
}否则{
节点=&（*节点）。右
}
}
*node=NewNode（键）
}

请注意，在检查循环上的地址和键时，我们使用间接运算符*
访问引用的数据
在函数的末尾，*node=NewNode（key）
执行您最初打算执行的操作；您正在将新创建的项分配给根指针、左指针或右指针。
您似乎混淆了指针的用法
当您执行node=t.root
时，您只需使node
指向t.root
指向的任何对象
稍后，当您执行node=NewNode（key）
时，您会使node
指向一个新创建的项，而这不是您想要的；您希望使t.root
指向该新项
由于您打算修改类型为*Node
（root
、left
和right
）的变量，因此我们需要一个指向它们的指针，因此类型为**Node
的变量还需要一个间接级别
您可以首先使节点
指向t.root
，节点：=&t.root
，然后继续循环
您可以尝试以下方法：
func (t *BST) Insert3(key int) {
    node := &t.root
    for *node != nil {
        if key < (*node).key {
            node = &(*node).left
        } else {
            node = &(*node).right
        }
    }
    *node = NewNode(key)
}

func（t*BST）Insert3（键int）{
节点：=&t.root
对于*节点！=nil{
如果键<（*节点）。键{
节点=&（*节点）。左
}否则{
节点=&（*节点）。右
}
}
*node=NewNode（键）
}

请注意，在检查循环上的地址和键时，我们使用间接运算符*
访问引用的数据
在函数的末尾，*node=NewNode（key）
执行您最初打算执行的操作；您正在将新创建的项分配给根指针、左指针或右指针