方式

概念

  • 前序遍历：递归遍历根->左->右
  • 中序遍历：递归遍历左->根->右
  • 后续遍历：递归遍历左->右->中
  • 层序遍历：由根节点开始一层层的遍历

其实前序遍历、中序遍历、后序遍历里面的前、中、后指的是根结点的位置。以下面这棵树来举例说明。

存储结构

1
2
3
4
5
type Node struct {
    Value string
    Left *Node
    Right *Node
}

前序遍历

前序遍历要求先遍历根节点，然后遍历左子树，左后便利右子树。注意这里指的是【子树】不是孩子。所以遍历顺序为：
A,B,D,H,I,E,J,C,F,K,G

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func PreRange(node *Node) []string  {
	if node == nil {
		return nil
	}
	list := make([]string, 0)
	list = append(list, node.Value)

	leftList := PreRange(node.Left)
	if leftList != nil {
		list = append(list, leftList...)
	}
	rightList := PreRange(node.Right)
	if rightList != nil {
		list = append(list, rightList...)
	}

	return list
}

中序遍历

中序遍历要求先遍历左子树，然后遍历根节点，最后遍历右子树。所以顺序为：
H,D,I,B,E,J,A,F,K,C,G

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func MidRange(node *Node) []string {
	if node == nil {
		return nil
	}
	list := make([]string,0)
	leftList := MidRange(node.Left)
	if leftList != nil {
		list = append(list, leftList...)
	}
	list = append(list, node.Value)
	rightList := MidRange(node.Right)
	if rightList != nil {
		list = append(list, rightList...)
	}

	return list
}

后续遍历

后序遍历要求先遍历左子树，然后遍历右子树，最后遍历根节点。所以顺序为：
H,I,D,J,E,B,K,F,G,C,A

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func SufRange(node *Node) []string {
	if node == nil {
		return nil
	}
	list := make([]string,0)
	leftList := SufRange(node.Left)
	if leftList != nil {
		list = append(list, leftList...)
	}
	rightList := SufRange(node.Right)
	if rightList != nil {
		list = append(list, rightList...)
	}
	list = append(list, node.Value)

	return list
}

层序遍历

层序遍历其实就是从根节点开始从左到右一层层开始遍历所有节点， 所以顺序为：
A,B,C,D,E,F,G,H,I,J,K

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

func LevelTraversal(node *Node) []string {
	if node == nil {
		return nil
	}

	nodeList := make([]*Node, 0)
	nodeList = append(nodeList, node)

	return RecursionTraversal(nodeList)
}

func RecursionTraversal(nodeList []*Node) []string {
	if len(nodeList) == 0 {
		return nil
	}

	list := make([]string,0)
	nextNodeList := make([]*Node, 0)
	for _, node := range nodeList {
		list = append(list, node.Value)

		if node.Left != nil {
			nextNodeList = append(nextNodeList, node.Left)
		}

		if node.Right != nil {
			nextNodeList =append(nextNodeList, node.Right)
		}
	}

	if len(nextNodeList) > 0 {
		s := RecursionTraversal(nextNodeList)
		 if len(s) > 0 {
		 	list = append(list, s...)
		 }
	}

	return list
}