4：结构体

结构体

• 不论地址还是结构本身都采用 . 来访问变量
• 工厂函数 - // 返回一个局部变量的地址给外面使用

package main

type treenode struct {
   value       int
   left, right *treenode
}

// 工厂函数的创建
func createnode(value int) *treenode {
   // 返回一个局部变量的地址给外面使用
   return &treenode{value: value}
}
func main() {
   var root treenode
   root = treenode{value: 3}
   root.left = &treenode{}
   root.right = &treenode{5, nil, nil}
   root.right.left = new(treenode)
   root.left.right = createnode(2)

}

为结构体定义方法

• // 如果我们的接收者不使用 　*　只会是值的传递

• 
  func (node *treenode) servalue(value int) {
     node.value = value
  

package main

import "fmt"

type treenode struct {
   value       int
   left, right *treenode
}

// 如果我们的接收者不使用 　*　只会是值的传递
func (node *treenode) servalue(value int) {
   node.value = value
}

// 定义一个接收者
func (node treenode) print() {
   fmt.Print(node.value)
}

// 工厂函数的创建
func createnode(value int) *treenode {
   // 返回一个局部变量的地址给外面使用
   return &treenode{value: value}
}
func main() {
   var root treenode
   root = treenode{value: 3}
   root.left = &treenode{}
   root.right = &treenode{5, nil, nil}
   root.right.left = new(treenode)
   root.left.right = createnode(2)
   root.print()
}

使用指针作为方法的接收者

• 只有使用指针才可以改变结构体的内容
• nil指针也可以调用方法

package main

import "fmt"

type treenode struct {
	value       int
	left, right *treenode
}

// 如果我们的接收者不使用 　*　只会是值的传递
func (node *treenode) servalue(value int) {
	if node == nil {
		fmt.Println("setting value to nil node")
		return
	}
	node.value = value
}

// 定义一个接收者
func (node treenode) print() {
	fmt.Print(node.value, " ")
}

// 工厂函数的创建
func createnode(value int) *treenode {
	// 返回一个局部变量的地址给外面使用
	return &treenode{value: value}
}
func (node *treenode) traverse() {
	if node == nil {
		return
	}
	node.left.traverse()
	node.print()
	node.right.traverse()
}
func main() {
	var root treenode
	root = treenode{value: 3}
	root.left = &treenode{}
	root.right = &treenode{5, nil, nil}
	root.right.left = new(treenode)
	root.left.right = createnode(2)
	//root.print()
	proot := &root
	proot.traverse()
}

包和封装

按照大小写字母—首字母大写代表public ，小写代表

一个目录只可以包含一个包

扩展已经有的类型

• 定义别名 type Quene [ ] int

• 使用组合

• type myTreeNode struct {
     node *tree.Node
  }
  

---

leftNode := myTreeNode{myNode.node.Left}

rightNode := &myTreeNode{myNode.node.Right}

此代码的问题在于：
postOrder() 方法中的递归调用传递的是一个新的 myTreeNode 对象，而不是指向同一节点的指针。这意味着在递归过程中，无法更新原始节点的值。应该传递指针而不是创建新的对象。
在条件判断语句中，应该首先检查 myNode 是否为 nil，以避免出现空指针解引用的情况。
正确的代码应该像这样：

type myTreeNode struct {
	node *tree.Node
}

func (myNode *myTreeNode) postOrder() {
	if myNode == nil || myNode.node == nil {
		return
	}
	leftNode := &myTreeNode{myNode.node.Left}
	rightNode := &myTreeNode{myNode.node.Right}
	leftNode.postOrder()
	rightNode.postOrder()
	myNode.node.Print()
}

package main

import "golang/tree"

type myTreeNode struct {
   node *tree.Node
}

func (myNode *myTreeNode) postOrder() {
   if myNode == nil || myNode.node == nil {
      return
   }
   leftNode := myTreeNode{myNode.node.Left}
   rightNode := &myTreeNode{myNode.node.Right}
   leftNode.postOrder()
   rightNode.postOrder()
   myNode.node.Print()
}
func main() {
   var root tree.Node
   root = tree.Node{Value: 3}
   root.Left = &tree.Node{}
   root.Right = &tree.Node{5, nil, nil}
   root.Right.Left = new(tree.Node)
   root.Left.Right = tree.Createnode(2)
   //root.print()
   proot := &root
   proot.Traverse()
}

使用内嵌类型扩展已有类型

1. embedding 在下述代码

   type myTreeNode struct {
     体现出了内嵌------- *tree.Node
   }
   

---

package main

import (
	"fmt"
	"golang/tree"
)

type myTreeNode struct {
	*tree.Node
}

func (myNode *myTreeNode) postOrder() {
	if myNode == nil || myNode.Node == nil {
		return
	}
	leftNode := &myTreeNode{Node: myNode.Left}
	rightNode := &myTreeNode{myNode.Right}
	leftNode.postOrder()
	rightNode.postOrder()
	myNode.Print()
}
func main() {

	root := myTreeNode{&tree.Node{
		Value: 3,
	}}
	root.Left = &tree.Node{}
	root.Right = &tree.Node{5, nil, nil}
	root.Right.Left = new(tree.Node)
	root.Left.Right = tree.Createnode(2)
	//root.print()
	proot := &root
	fmt.Println("traverse-----------------")
	proot.Traverse()
	fmt.Println("postorder---------------")
	root.postOrder()
}