1.结构的定义

  1. type identifier struct {
  2. field1 type1
  3. field2 type2
  4. ...
  5. }

2.结构体的创建

表达式 new(Type) 和 &Type{} 是等价的
& 不是必须的

  1. root := TreeNode{Value: 3}
  2. root.Left = &TreeNode{}
  3. root.Right = &TreeNode{5, nil, nil}
  4. root.Left.Right = new(TreeNode)

3.为结构体定义方法

  1. func (node treeNode) print() {
  2. fmt.Print(node.value)
  3. }
  4. func (node *treeNode) setValue(value int) {
  5. node.value = value
  6. }

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

  1. func (node *treeNode) setValue(value int) {
  2. if node == nil {
  3. fmt.Println("setting value to nil node,ignored")
  4. return
  5. }
  6. node.value = value
  7. }

二叉树

  1. package main
  2. import "fmt"
  3. type treeNode struct {
  4. value int
  5. left, right *treeNode
  6. }
  7. func (node treeNode) print() {
  8. fmt.Print(node.value)
  9. fmt.Print(" ")
  10. }
  11. func (node *treeNode) setValue(value int) {
  12. if node == nil {
  13. fmt.Println("setting value to nil node,ignored")
  14. }
  15. node.value = value
  16. }
  17. func (node *treeNode) traverse() {
  18. if node == nil {
  19. return
  20. }
  21. node.left.traverse()
  22. node.print()
  23. node.right.traverse()
  24. }
  25. func createNode(value int) *treeNode {
  26. return &treeNode{value: value}
  27. }
  28. func main() {
  29. var root treeNode
  30. // fmt.Println(root)
  31. root = treeNode{value: 3}
  32. root.left = &treeNode{}
  33. root.right = &treeNode{5, nil, nil}
  34. root.right.left = new(treeNode)
  35. // nodes := []treeNode {
  36. // {value: 3},
  37. // {},
  38. // {6, nil, &root},
  39. // }
  40. // fmt.Println(nodes)
  41. root.left.right = createNode(2)
  42. root.print()
  43. root.right.left.setValue(4)
  44. root.right.left.print()
  45. fmt.Println()
  46. root.print()
  47. root.setValue(100)
  48. pRoot := &root
  49. pRoot.print()
  50. pRoot.setValue(200)
  51. pRoot.print()
  52. root.traverse()
  53. }