Golang二叉树的4种遍历方式（先序，中序，后序，层序）

本文只涉及使用Golang实现的二叉树的先序、中序、后序和层序的递归遍历方式。

二叉树

树的任意节点至多包含两棵子树。

二叉树的遍历

二叉树的遍历是指从二叉树的根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问一次，且仅被访问一次。

题目数据

我们以上面的这个二叉树图为基础数据编写代码

Code

基础结构

二叉树需要存储自身节点数据，以及最多两个子节点的索引

type BinaryTree struct {
	Value     int         `json:"value,omitempty"`
	LeftNode  *BinaryTree `json:"left_node,omitempty"`
	RightNode *BinaryTree `json:"right_node,omitempty"`
}

二叉树模型代码

 结合上面的节点结构体代码，我们把模拟数据用代码表示出来

//根节点
var rootNode *BinaryTree = &BinaryTree{
	Value: 1,
	LeftNode: &BinaryTree{
		Value: 2,
		LeftNode: &BinaryTree{
			Value: 4,
			RightNode: &BinaryTree{
				Value:     6,
				LeftNode:  &BinaryTree{Value: 7},
				RightNode: &BinaryTree{Value: 8},
			},
		},
	},
	RightNode: &BinaryTree{
		Value:     3,
		RightNode: &BinaryTree{Value: 5},
	},
}

1. 先序递归遍历

先输出自己的值，再遍历输出左子树的值，再遍历输出右子树的值。

我们先看图解出参考答案：1 2 4 6 7 8 3 5

编码：

// 先序遍历
func RecursionPreorderTraversal(node *BinaryTree) {
	//如果当前节点为nil，则结束遍历
	if node == nil {
		return
	}
	// 先输出自身节点的值
	fmt.Printf("%v ", node.Value)
	// 递归遍历左子树
	RecursionPreorderTraversal(node.LeftNode)
	// 递归遍历右子树
	RecursionPreorderTraversal(node.RightNode)
}

func main(){
    RecursionPreorderTraversal(rootNode)
}

运行输出，符合预期结果

 2. 中序递归遍历

先遍历输出左子树，再输出自身的值，再遍历输出右子树的值

我们先看图解出参考答案：4 7 6 8 2 1 3 5

编码：

// 中序遍历
func RecursionMiddleorderTraversal(node *BinaryTree) {
	//如果当前节点为nil，则结束遍历
	if node == nil {
		return
	}

	// 先递归遍历左子树
	RecursionMiddleorderTraversal(node.LeftNode)
	// 再输出自身节点的值
	fmt.Printf("%v ", node.Value)
	// 最后递归遍历右子树
	RecursionMiddleorderTraversal(node.RightNode)
}

func main(){
    RecursionMiddleorderTraversal(rootNode)
}

运行输出，符合预期结果

 3. 后序递归遍历

先遍历输出左子树的值，再遍历输出右子树，最后输出自身节点的值

我们先看图解出参考答案：7 8 6 4 2 5 3 1

编码：

// 后序遍历
func RecursionPostorderTraversal(node *BinaryTree) {
	//如果当前节点为nil，则结束遍历
	if node == nil {
		return
	}

	// 先递归遍历左子树
	RecursionPostorderTraversal(node.LeftNode)
	// 再递归遍历右子树
	RecursionPostorderTraversal(node.RightNode)
	// 最后输出自身节点的值
	fmt.Printf("%v ", node.Value)
}

func main(){
    RecursionPostorderTraversal(rootNode)
}

运行输出，符合预期结果

4. 层序递归遍历

 按照节点深度，由树根部（深度为0），一层一层向下遍历子节点

我们先看图解出参考答案：1 2 3 4 5 6 7 8

层序遍历的代码稍显复杂

编码：

// 从root节点开始层级遍历
func LevelTraversal(rootNode *BinaryTree) {
	//如果当前节点为nil，直接结束遍历
	if rootNode == nil {
		return
	}

	// 封装成slice
	var nodeSlice []*BinaryTree
	nodeSlice = append(nodeSlice, rootNode)

	// 开始递归遍历
	RecursionTraversal(nodeSlice)
}

// 递归遍历核心
func RecursionTraversal(nodeSlice []*BinaryTree) {
	// 如果当前层级slice为空，则结束遍历
	if len(nodeSlice) == 0 {
		return
	}

	// 创建新的节点slice，存储下一层需要遍历的node
	var nextSlice []*BinaryTree

	//遍历当前nodeSlice
	for i := 0; i < len(nodeSlice); i++ {
		//取出要遍历的node
		node := nodeSlice[i]

		//输出当前node的值
		fmt.Printf("%v ", node.Value)

		//当前node左子节点append到下一层node slice中
		if node.LeftNode != nil {
			nextSlice = append(nextSlice, node.LeftNode)
		}

		//当前node右子节点append到下一层node slice中
		if node.RightNode != nil {
			nextSlice = append(nextSlice, node.RightNode)
		}
	}

	//递归遍历下一层的node slice
	RecursionTraversal(nextSlice)
}

func main(){
    LevelTraversal(rootNode)
}

运行输出，符合预期结果

到此结束。

有问题，或者建议请留言，谢谢。