• go语言｜数据结构：二叉树（1）创建与遍历方法

    树 Tree

    树是有限结点组成一个具有层次关系的集合。

    开始写代码前，先复习一遍基本概念：

    名词术语

    结点 Node

    也有写作“节点”，组成树的集合中的“元素”。

    根结点 Root

    没有前驱的结点叫做根结点

    结点的度 Node degree

    一个结点含有子树的个数

    树的度 Tree degree

    所有结点的度最大的那一个叫做树的度

    叶子结点 Leaf

    度为0的结点

    结点的层次 Level

    根为第一层，根的子节点为第二层，依次往下推

    深度 Depth

    树的总层数，就是高度树的高度Height

    二叉树 Binary Tree

    一种特殊的树，是结点的一个有限集合，且所有结点最多有2个子结点，即度只能是0,1,2。

    满二叉树 Full Binary Tree

    除叶子结点外，每一层上的所有结点都有两个子结点二叉树。它的每一个层次的结点数目都达到了最大值。
    结点总数M 和 总层数N 满足： M = 2^N - 1
    每层结点数m 和 层数n 满足： m = 2^(n-1)

    完全二叉树 Complete Binary Tree

    二叉树的叶节点只出现在最下层和次下层，并且最下层的结点都集中在该层的最左边。

    性质

    (1) 在二叉树中，第i层的结点总数不超过2^(i-1)；

    (2) 深度为h的二叉树最多有2^h-1个结点(h>=1)，最少有h个结点；

    (3) 对于任意一棵二叉树，其所有的叶结点数为：N0，而度为2的所有结点的数量为：N2，则：N0=N2+1，请观察上图；

    (4) 具有n个结点的完全二叉树的深度为int（log2n）+1

    (5)有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：

    若I为结点编号则 如果I<>1，则其父结点的编号为I/2；

    如果2*I<=N，则其左儿子（即左子树的根结点）的编号为2*I；若2*I>N，则无左儿子；

    如果2*I+1<=N，则其右儿子的结点编号为2*I+1；若2*I+1>N，则无右儿子。

    (6) 给定N个节点，能构成h(N)种不同的二叉树。h(N)为卡特兰数的第N项。h(n)=C(n,2*n)/(n+1)。

    二叉树的创建

    结点

    数据域 Data，使用 interface{} 好处是可以添加任意类型的数据结点

    左、右子树结点指针 Lchild, Rchild

    1. type btNode struct {
    2. 	Data   interface{}
    3. 	Lchild *btNode
    4. 	Rchild *btNode
    5. }

    二叉树

    1. type biTree struct {
    2. 	root *btNode
    3. }

    创建与访问

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	root *btNode
    13. }
    14.  
    15. func main() {
    16.  
    17. 	var tree *biTree
    18. 	var node1, node2, node3, node4 *btNode
    19. 	tree = new(biTree)
    20.  
    21. 	node1 = &btNode{Data: 1}
    22. 	node2 = &btNode{Data: 2}
    23. 	node3 = &btNode{Data: 3}
    24. 	node4 = &btNode{Data: 4}
    25.  
    26. 	tree.root = node1
    27. 	node1.Lchild = node2
    28. 	node1.Rchild = node3
    29. 	node2.Lchild = node4
    30.  
    31. 	fmt.Println(tree.root.Data)
    32. 	fmt.Println(tree.root.Lchild.Data)
    33. 	fmt.Println(tree.root.Rchild.Data)
    34. 	fmt.Println(tree.root.Lchild.Lchild.Data)
    35.  
    36. }
    37.  
    38. /*
    39. 1
    40. 2
    41. 3
    42. 4
    43. */

    用数组批量创建结点

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	root *btNode
    13. }
    14.  
    15. func NewTree() *biTree {
    16. 	return &biTree{}
    17. }
    18.  
    19. func newTreeNode(data interface{}) *btNode {
    20. 	return &btNode{
    21. 		Data:   data,
    22. 		Lchild: nil,
    23. 		Rchild: nil,
    24. 	}
    25. }
    26.  
    27. func main() {
    28.  
    29. 	list := []interface{}{1, 2, 3, 4, 5, 6}
    30. 	node := []*btNode{}
    31. 	tree := NewTree()
    32.  
    33. 	for _, data := range list {
    34. 		node = append(node, newTreeNode(data))
    35. 	}
    36.  
    37. 	tree.root = node[0]
    38. 	tree.root.Lchild = node[1]
    39. 	tree.root.Rchild = node[2]
    40. 	tree.root.Lchild.Lchild = node[3]
    41. 	tree.root.Lchild.Rchild = node[4]
    42. 	tree.root.Rchild.Lchild = node[5]
    43.  
    44. 	fmt.Println(tree.root.Data)
    45. 	fmt.Println(tree.root.Lchild.Data)
    46. 	fmt.Println(tree.root.Rchild.Data)
    47. 	fmt.Println(tree.root.Lchild.Lchild.Data)
    48. 	fmt.Println(tree.root.Lchild.Rchild.Data)
    49. 	fmt.Println(tree.root.Rchild.Lchild.Data)
    50.  
    51. }
    52.  
    53. /*
    54. 1
    55. 2
    56. 3
    57. 4
    58. 5
    59. 6
    60. */

    追加结点

    从上到下逐层且每一层从左到右访问二叉树，遇到首个空结点时就添加一结点。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	root *btNode
    13. }
    14.  
    15. func NewTree() *biTree {
    16. 	return &biTree{}
    17. }
    18.  
    19. func newTreeNode(data interface{}) *btNode {
    20. 	return &btNode{
    21. 		Data:   data,
    22. 		Lchild: nil,
    23. 		Rchild: nil,
    24. 	}
    25. }
    26.  
    27. func (bt *biTree) appendNode(data interface{}) {
    28. 	cur := bt.root
    29. 	if cur == nil { //空树则创建一个根结点
    30. 		bt.root = newTreeNode(data)
    31. 		return
    32. 	}
    33. 	Queue := []*btNode{cur}
    34. 	for len(Queue) > 0 {
    35. 		cur := Queue[0]
    36. 		Queue = Queue[1:]
    37. 		if cur.Lchild != nil {
    38. 			Queue = append(Queue, cur.Lchild)
    39. 		} else {
    40. 			cur.Lchild = newTreeNode(data)
    41. 			return
    42. 		}
    43. 		if cur.Rchild != nil {
    44. 			Queue = append(Queue, cur.Rchild)
    45. 		} else {
    46. 			cur.Rchild = newTreeNode(data)
    47. 			break
    48. 		}
    49. 	}
    50. }
    51.  
    52. func main() {
    53. 	tree := &biTree{}
    54. 	list := []interface{}{1, 2, 3, 4, 5, 6}
    55. 	for _, data := range list {
    56. 		tree.appendNode(data)
    57. 	}
    58.  
    59. 	fmt.Println(tree.root.Data)
    60. 	fmt.Println(tree.root.Lchild.Data)
    61. 	fmt.Println(tree.root.Rchild.Data)
    62. 	fmt.Println(tree.root.Lchild.Lchild.Data)
    63. 	fmt.Println(tree.root.Lchild.Rchild.Data)
    64. 	fmt.Println(tree.root.Rchild.Lchild.Data)
    65. 	tree.appendNode(0)
    66. 	fmt.Println(tree.root.Rchild.Rchild.Data)
    67.  
    68. }
    69.  
    70. /*
    71. 1
    72. 2
    73. 3
    74. 4
    75. 5
    76. 6
    77. 0
    78. */

    追加结点时的访问方法称为“层序”，层序访问整个二叉树只要把代码中追加结点的语句换成打印所有结点的数据域，即完成了二叉树的“层序遍历”：

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	root *btNode
    13. }
    14.  
    15. func NewTree() *biTree {
    16. 	return &biTree{}
    17. }
    18.  
    19. func newTreeNode(data interface{}) *btNode {
    20. 	return &btNode{
    21. 		Data:   data,
    22. 		Lchild: nil,
    23. 		Rchild: nil,
    24. 	}
    25. }
    26.  
    27. func levelorderPrint(bt *biTree) {
    28. 	cur := bt.root
    29. 	if cur == nil {
    30. 		fmt.Print("Empty Binary Tree")
    31. 	}
    32. 	Queue := []*btNode{cur}
    33. 	for len(Queue) > 0 {
    34. 		cur := Queue[0]
    35. 		Queue = Queue[1:]
    36. 		fmt.Print(cur.Data, " ")
    37. 		if cur.Lchild != nil {
    38. 			Queue = append(Queue, cur.Lchild)
    39. 		}
    40. 		if cur.Rchild != nil {
    41. 			Queue = append(Queue, cur.Rchild)
    42. 		}
    43. 	}
    44. 	fmt.Println()
    45. }
    46.  
    47. func (bt *biTree) appendNode(data interface{}) {
    48. 	cur := bt.root
    49. 	if cur == nil {
    50. 		bt.root = newTreeNode(data)
    51. 		return
    52. 	}
    53. 	Queue := []*btNode{cur}
    54. 	for len(Queue) > 0 {
    55. 		cur := Queue[0]
    56. 		Queue = Queue[1:]
    57. 		if cur.Lchild != nil {
    58. 			Queue = append(Queue, cur.Lchild)
    59. 		} else {
    60. 			cur.Lchild = newTreeNode(data)
    61. 			return
    62. 		}
    63. 		if cur.Rchild != nil {
    64. 			Queue = append(Queue, cur.Rchild)
    65. 		} else {
    66. 			cur.Rchild = newTreeNode(data)
    67. 			break
    68. 		}
    69. 	}
    70. }
    71.  
    72. func main() {
    73.  
    74. 	tree := &biTree{}
    75. 	list := []interface{}{1, 2, 3, 4, 5, 6}
    76. 	for _, data := range list {
    77. 		tree.appendNode(data)
    78. 	}
    79.  
    80. 	levelorderPrint(tree)
    81.  
    82. 	tree.appendNode(0)
    83. 	levelorderPrint(tree)
    84.  
    85. }
    86.  
    87. /*
    88. 1 2 3 4 5 6 
    89. 1 2 3 4 5 6 0 
    90. */

    二叉树的遍历

    层序遍历

    自上而下，自左至右逐层访问树的结点的过程就是层序遍历

    上面已写过打印版的层序遍历函数，稍作修改让它变成一个二叉树方法，并返回一个数组。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	root *btNode
    13. }
    14.  
    15. func (bt *biTree) levelorder() []interface{} {
    16. 	var list []interface{}
    17. 	cur := bt.root
    18. 	if cur == nil {
    19. 		return list
    20. 	}
    21. 	Queue := []*btNode{cur}
    22. 	for len(Queue) > 0 {
    23. 		cur := Queue[0]
    24. 		Queue = Queue[1:]
    25. 		list = append(list, cur.Data)
    26. 		if cur.Lchild != nil {
    27. 			Queue = append(Queue, cur.Lchild)
    28. 		}
    29. 		if cur.Rchild != nil {
    30. 			Queue = append(Queue, cur.Rchild)
    31. 		}
    32. 	}
    33. 	return list
    34. }
    35.  
    36. func createTree(list []interface{}) *biTree {
    37. 	btree := &biTree{}
    38. 	if len(list) > 0 {
    39. 		btree.root = &btNode{Data: list[0]}
    40. 		for _, data := range list[1:] {
    41. 			btree.appendNode(data)
    42. 		}
    43. 	}
    44. 	return btree
    45. }
    46.  
    47. func (bt *biTree) appendNode(data interface{}) {
    48. 	cur := bt.root
    49. 	if cur == nil {
    50. 		bt = &biTree{}
    51. 		return
    52. 	}
    53. 	Queue := []*btNode{cur}
    54. 	for len(Queue) > 0 {
    55. 		cur := Queue[0]
    56. 		Queue = Queue[1:]
    57. 		if cur.Lchild != nil {
    58. 			Queue = append(Queue, cur.Lchild)
    59. 		} else {
    60. 			cur.Lchild = &btNode{Data: data}
    61. 			return
    62. 		}
    63. 		if cur.Rchild != nil {
    64. 			Queue = append(Queue, cur.Rchild)
    65. 		} else {
    66. 			cur.Rchild = &btNode{Data: data}
    67. 			break
    68. 		}
    69. 	}
    70. }
    71.  
    72. func main() {
    73.  
    74. 	list := []interface{}{1, 2, 3, 4, 5, 6}
    75.  
    76. 	tree := createTree(list)
    77. 	fmt.Println(tree.levelorder())
    78.  
    79. 	tree.appendNode(0)
    80. 	fmt.Println(tree.levelorder())
    81.  
    82. }
    83.  
    84. /*
    85. [1 2 3 4 5 6]
    86. [1 2 3 4 5 6 0]
    87. */

    先序遍历

    先遍历根节点，再遍历左节点，最后遍历右节点

    中序遍历

    先遍历左节点，再遍历根节点，最后遍历右节点

    后序遍历

    先遍历左节点，再遍历右节点，最后遍历根节点

    三种遍历的递归打印版：

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	root *btNode
    13. }
    14.  
    15. func preorderPrint(bt *btNode) {
    16. 	if bt == nil {
    17. 		return
    18. 	}
    19. 	fmt.Print(bt.Data, " ")
    20. 	preorderPrint(bt.Lchild)
    21. 	preorderPrint(bt.Rchild)
    22.  
    23. }
    24.  
    25. func inorderPrint(bt *btNode) {
    26. 	if bt == nil {
    27. 		return
    28. 	}
    29. 	inorderPrint(bt.Lchild)
    30. 	fmt.Print(bt.Data, " ")
    31. 	inorderPrint(bt.Rchild)
    32. }
    33.  
    34. func postorderPrint(bt *btNode) {
    35. 	if bt != nil { //这样写就不用return语句
    36. 		postorderPrint(bt.Lchild)
    37. 		postorderPrint(bt.Rchild)
    38. 		fmt.Print(bt.Data, " ")
    39. 	}
    40. }
    41.  
    42. func createTree(list []interface{}) *biTree {
    43. 	btree := &biTree{}
    44. 	if len(list) > 0 {
    45. 		btree.root = &btNode{Data: list[0]}
    46. 		for _, data := range list[1:] {
    47. 			btree.appendNode(data)
    48. 		}
    49. 	}
    50. 	return btree
    51. }
    52.  
    53. func (bt *biTree) appendNode(data interface{}) {
    54. 	cur := bt.root
    55. 	if cur == nil {
    56. 		bt = &biTree{}
    57. 		return
    58. 	}
    59. 	Queue := []*btNode{cur}
    60. 	for len(Queue) > 0 {
    61. 		cur := Queue[0]
    62. 		Queue = Queue[1:]
    63. 		if cur.Lchild != nil {
    64. 			Queue = append(Queue, cur.Lchild)
    65. 		} else {
    66. 			cur.Lchild = &btNode{Data: data}
    67. 			return
    68. 		}
    69. 		if cur.Rchild != nil {
    70. 			Queue = append(Queue, cur.Rchild)
    71. 		} else {
    72. 			cur.Rchild = &btNode{Data: data}
    73. 			break
    74. 		}
    75. 	}
    76. }
    77.  
    78. func main() {
    79.  
    80. 	list := []interface{}{1, 2, 3, 4, 5, 6, 7, 8}
    81. 	tree := createTree(list)
    82.  
    83. 	preorderPrint(tree.root)
    84. 	fmt.Println()
    85. 	inorderPrint(tree.root)
    86. 	fmt.Println()
    87. 	postorderPrint(tree.root)
    88. 	fmt.Println()
    89.  
    90. }
    91.  
    92. /*
    93. 1 2 4 8 5 3 6 7 
    94. 8 4 2 5 1 6 3 7 
    95. 8 4 5 2 6 7 3 1 
    96. */

    三个函数核心代码次序的对比：

    先序：“根左右”
                    fmt.Print(bt.Data, " ")
                    preorderPrint(bt.Lchild)
                    preorderPrint(bt.Rchild)
    中序：“左根右”
                    inorderPrint(bt.Lchild)
                    fmt.Print(bt.Data, " ")
                    inorderPrint(bt.Rchild)
    后序：“左右根”
                    postorderPrint(bt.Lchild)
                    postorderPrint(bt.Rchild)
                    fmt.Print(bt.Data, " ")

    递归非打印版：

    在打印版的基础上稍作修改，返回一个数组

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	root *btNode
    13. }
    14.  
    15. func (bt *btNode) preorder() []interface{} {
    16. 	var res []interface{} //or: res := make([]interface{}, 0)
    17. 	if bt != nil {
    18. 		res = append(res, bt.Data)
    19. 		res = append(res, bt.Lchild.preorder()...)
    20. 		res = append(res, bt.Rchild.preorder()...)
    21. 	}
    22. 	return res
    23. }
    24.  
    25. func (bt *btNode) inorder() []interface{} {
    26. 	var res []interface{}
    27. 	if bt != nil {
    28. 		res = append(res, bt.Lchild.inorder()...)
    29. 		res = append(res, bt.Data)
    30. 		res = append(res, bt.Rchild.inorder()...)
    31. 	}
    32. 	return res
    33. }
    34.  
    35. func (bt *btNode) postorder() []interface{} {
    36. 	var res []interface{}
    37. 	if bt != nil {
    38. 		res = append(res, bt.Lchild.postorder()...)
    39. 		res = append(res, bt.Rchild.postorder()...)
    40. 		res = append(res, bt.Data)
    41. 	}
    42. 	return res
    43. }
    44.  
    45. func createTree(list []interface{}) *biTree {
    46. 	btree := &biTree{}
    47. 	if len(list) > 0 {
    48. 		btree.root = &btNode{Data: list[0]}
    49. 		for _, data := range list[1:] {
    50. 			btree.appendNode(data)
    51. 		}
    52. 	}
    53. 	return btree
    54. }
    55.  
    56. func (bt *biTree) appendNode(data interface{}) {
    57. 	cur := bt.root
    58. 	if cur == nil {
    59. 		bt = &biTree{}
    60. 		return
    61. 	}
    62. 	Queue := []*btNode{cur}
    63. 	for len(Queue) > 0 {
    64. 		cur := Queue[0]
    65. 		Queue = Queue[1:]
    66. 		if cur.Lchild != nil {
    67. 			Queue = append(Queue, cur.Lchild)
    68. 		} else {
    69. 			cur.Lchild = &btNode{Data: data}
    70. 			return
    71. 		}
    72. 		if cur.Rchild != nil {
    73. 			Queue = append(Queue, cur.Rchild)
    74. 		} else {
    75. 			cur.Rchild = &btNode{Data: data}
    76. 			break
    77. 		}
    78. 	}
    79. }
    80.  
    81. func main() {
    82.  
    83. 	list := []interface{}{1, 2, 3, 4, 5, 6, 7, 8}
    84. 	tree := createTree(list)
    85.  
    86. 	fmt.Println(tree.root.preorder())
    87. 	fmt.Println(tree.root.inorder())
    88. 	fmt.Println(tree.root.postorder())
    89.  
    90. }
    91.  
    92. /*
    93. [1 2 4 8 5 3 6 7]
    94. [8 4 2 5 1 6 3 7]
    95. [8 4 5 2 6 7 3 1]
    96. */

    非递归方法：

    递推法可以写成二叉树的方法，不像递归法要反复调用只能写成结点的方法。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	root *btNode
    13. }
    14.  
    15. func (bt *biTree) preOrder() []interface{} {
    16. 	var res []interface{}
    17. 	p := bt.root
    18. 	Stack := make([]*btNode, 0)
    19. 	for p != nil || len(Stack) > 0 {
    20. 		for p != nil {
    21. 			res = append(res, p.Data)
    22. 			Stack = append(Stack, p)
    23. 			p = p.Lchild
    24. 		}
    25. 		if len(Stack) > 0 {
    26. 			p = Stack[len(Stack)-1]
    27. 			Stack = Stack[:len(Stack)-1]
    28. 			p = p.Rchild
    29. 		}
    30. 	}
    31. 	return res
    32. }
    33.  
    34. func (bt *biTree) inOrder() []interface{} {
    35. 	var res []interface{}
    36. 	p := bt.root
    37. 	Stack := make([]*btNode, 0)
    38. 	for p != nil || len(Stack) > 0 {
    39. 		for p != nil {
    40. 			Stack = append(Stack, p)
    41. 			p = p.Lchild
    42. 		}
    43. 		if len(Stack) > 0 {
    44. 			p = Stack[len(Stack)-1]
    45. 			res = append(res, p.Data)
    46. 			Stack = Stack[:len(Stack)-1]
    47. 			p = p.Rchild
    48. 		}
    49. 	}
    50. 	return res
    51. }
    52.  
    53. func (bt *biTree) postOrder() []interface{} {
    54. 	var res []interface{}
    55. 	var cur, pre *btNode
    56. 	Stack := make([]*btNode, 0)
    57. 	Stack = append(Stack, bt.root)
    58. 	for len(Stack) > 0 {
    59. 		cur = Stack[len(Stack)-1]
    60. 		if cur.Lchild == nil && cur.Rchild == nil ||
    61. 			pre != nil && (pre == cur.Lchild || pre == cur.Rchild) {
    62. 			res = append(res, cur.Data)
    63. 			Stack = Stack[:len(Stack)-1]
    64. 			pre = cur
    65. 		} else {
    66. 			if cur.Rchild != nil {
    67. 				Stack = append(Stack, cur.Rchild)
    68. 			}
    69. 			if cur.Lchild != nil {
    70. 				Stack = append(Stack, cur.Lchild)
    71. 			}
    72. 		}
    73. 	}
    74. 	return res
    75. }
    76.  
    77. func createTree(list []interface{}) *biTree {
    78. 	btree := &biTree{}
    79. 	if len(list) > 0 {
    80. 		btree.root = &btNode{Data: list[0]}
    81. 		for _, data := range list[1:] {
    82. 			btree.appendNode(data)
    83. 		}
    84. 	}
    85. 	return btree
    86. }
    87.  
    88. func (bt *biTree) appendNode(data interface{}) {
    89. 	cur := bt.root
    90. 	if cur == nil {
    91. 		bt = &biTree{}
    92. 		return
    93. 	}
    94. 	Queue := []*btNode{cur}
    95. 	for len(Queue) > 0 {
    96. 		cur := Queue[0]
    97. 		Queue = Queue[1:]
    98. 		if cur.Lchild != nil {
    99. 			Queue = append(Queue, cur.Lchild)
    100. 		} else {
    101. 			cur.Lchild = &btNode{Data: data}
    102. 			return
    103. 		}
    104. 		if cur.Rchild != nil {
    105. 			Queue = append(Queue, cur.Rchild)
    106. 		} else {
    107. 			cur.Rchild = &btNode{Data: data}
    108. 			break
    109. 		}
    110. 	}
    111. }
    112.  
    113. func main() {
    114.  
    115. 	list := []interface{}{1, 2, 3, 4, 5, 6, 7, 8}
    116. 	tree := createTree(list)
    117.  
    118. 	fmt.Println(tree.preOrder())
    119. 	fmt.Println(tree.inOrder())
    120. 	fmt.Println(tree.postOrder())
    121.  
    122. }
    123.  
    124. /*
    125. [1 2 4 8 5 3 6 7]
    126. [8 4 2 5 1 6 3 7]
    127. [8 4 5 2 6 7 3 1]
    128. */

    更多内容请见下集分解......

  • 相关阅读:
    Vivado Synthesis - getting a Segmentation fault after using up a lot of memory.
    Docker搭建官方私有仓库registry及相关配置
    装饰模式 rust和java的实现
    回到街头 - 数字时尚嘉年华：Web3的时尚未来，4月香港兰桂坊盛大启幕
    NLP实践！文本语法纠错模型实战，搭建你的贴身语法修改小助手 ⛵
    【Python工程师之高性能爬虫】
    [最短路]猛犸不上 Ban 2021RoboCom决赛D
    C++ Reference: Standard C++ Library reference: C Library: cmath: remquo
    JSP项目进度管理系统myeclipse开发sql数据库BS模式java编程网页结构
    WPF 分组
  • 原文地址：https://blog.csdn.net/boysoft2002/article/details/126556510