• 每个目录一个包
  • main包包含可执行入口
  • 为结构定义的方法必须放在同一个包内
  • 为结构定义的方法必须放在同一个包内
  • 可以是不同文件

node.go

  1. package tree
  3. import "fmt"
  5. type TreeNode struct {
  6.     Value int
  7.     Left, Right *TreeNode
  8. }
  10. func (node TreeNode) Print() {
  11.     fmt.Print(node.Value)
  12.     fmt.Print(" ")
  13. }
  15. func (node *TreeNode) SetValue(value int) {
  16.     if node == nil {
  17.         fmt.Println("setting value to nil node,ignored")
  18.     }
  19.     node.Value = value
  20. }
  22. func (node *TreeNode) Traverse() {
  23.     if node == nil {
  24.         return
  25.     }
  27.     node.Left.Traverse()
  28.     node.Print()
  29.     node.Right.Traverse()
  30. }
  32. func createNode(value int) *TreeNode {
  33.     return &TreeNode{Value: value}
  34. }

entry.go

  1. package main
  3. import "go_code/project04/tree"
  5. func main() {
  6.     var root tree.TreeNode
  7.     // fmt.Println(root)
  8.     root = tree.TreeNode{Value: 3}
  9.     root.Left = &tree.TreeNode{}
  10.     root.Right = &tree.TreeNode{5, nil, nil}
  11.     root.Right.Left = new(tree.TreeNode)
  13.     root.Traverse()
  14. }

目录结构
image.png

如何扩充系统类型或者别人的类型

  • 定义别名 ```go package main

import “go_code/project04/tree” import “fmt”

type myTreeNode struct { node *tree.TreeNode }

func (myNode *myTreeNode) postOrder() { if myNode == nil || myNode.node == nil{ return }

  1. left := myTreeNode{myNode.node.Left}
  2. left.postOrder()
  3. right := myTreeNode{myNode.node.Right}
  4. right.postOrder()
  5. myNode.node.Print()

}

func main() { var root tree.TreeNode // fmt.Println(root) root = tree.TreeNode{Value: 3} root.Left = &tree.TreeNode{} root.Right = &tree.TreeNode{5, nil, nil} root.Right.Left = new(tree.TreeNode)

  1. root.Traverse()
  2. fmt.Println()
  3. myRoot := myTreeNode{&root}
  4. myRoot.postOrder()
  5. fmt.Println()

}

  2. - 使用组合
  3. ```go
  4. package queue
  6. type Queue []int
  8. func (q *Queue) Push(v int) {
  9.     *q = append(*q, v)
  10. }
  12. func (q *Queue) Pop() int {
  13.     head := (*q)[0]
  14.     *q = (*q)[1:]
  15.     return head
  16. }
  18. func (q *Queue) IsEmpty() bool {
  19.     return len(*q) == 0
  20. }
  1. package main
  3. import (
  4.     "go_code/project04/queue"
  5.     "fmt"
  6. )
  8. func main() {
  9.     q := queue.Queue{1}
  11.     q.Push(2)
  12.     q.Push(3)
  13.     fmt.Println(q.Pop())
  14.     fmt.Println(q.Pop())
  15.     fmt.Println(q.IsEmpty())
  16.     fmt.Println(q.Pop())
  17.     fmt.Println(q.IsEmpty())
  18. }
  • 使用内嵌 ```go package main

import “go_code/project04/tree” import “fmt”

type myTreeNode struct { *tree.TreeNode //Embedding 内嵌 }

func (myNode *myTreeNode) postOrder() { if myNode == nil || myNode.TreeNode == nil{ return }

  1. left := myTreeNode{myNode.Left}
  2. left.postOrder()
  3. right := myTreeNode{myNode.Right}
  4. right.postOrder()
  5. myNode.Print()

}

func (myNode *myTreeNode) Traverse() { fmt.Println(“this method is shadowed “) }

func main() { // var root tree.TreeNode // fmt.Println(root) root := myTreeNode{&tree.TreeNode{Value: 3}} root.Left = &tree.TreeNode{} root.Right = &tree.TreeNode{5, nil, nil} root.Right.Left = new(tree.TreeNode)

  1. root.Traverse()
  2. fmt.Println()
  3. root.TreeNode.Traverse()
  4. fmt.Println()
  5. root.postOrder()
  6. fmt.Println()
  7. // myRoot := myTreeNode{&root}
  8. // myRoot.postOrder()
  9. // fmt.Println()

} ```