数据结构与算法 — 树的常见操作（Golang）_golang 树结构，重磅消息

package main

import "fmt"

type Node struct {
	Data  int
	Left  \*Node
	Right \*Node
}

//前序遍历
func PreOrder(node \*Node) {
	if node != nil {
		fmt.Print(" ",node.Data)
		PreOrder(node.Left)
		PreOrder(node.Right)
	}
}

//中序遍历
func InOrder(node \*Node) {
	if node != nil {
		InOrder(node.Left)
		fmt.Print(" ",node.Data)
		InOrder(node.Right)
	}
}

//后序遍历
func PostOrder(node \*Node) {
	if node != nil {
		PostOrder(node.Left)
		PostOrder(node.Right)
		fmt.Print(" ",node.Data)
	}
}

func CreateTreeNode()\*Node  {//p80
	node9 := &Node{
		Data: 9,
		Left: nil,
		Right: nil,
	}

	node10 := &Node{
		Data: 10,
		Left: nil,
		Right: nil,
	}

	node4:= &Node{
		Data: 4,
		Left: nil,
		Right: nil,
	}

	node2 := &Node{
		Data: 2,
		Left: node9,
		Right: node10,
	}

	node8 := &Node{
		Data: 8,
		Left: nil,
		Right: node4,
	}

	node3 := &Node {
		Data: 3,
		Left: node2,
		Right: node8,
	}
	return node3
}

func main() {
	rootNode := CreateTreeNode()
	PreOrder(rootNode)
	fmt.Println()
	InOrder(rootNode)
	fmt.Println()
	PostOrder(rootNode)
}

3.1.5 三种遍历的时间/空间复杂度

参考1：二叉树的前序遍历、中序遍历、后序遍历、层序遍历的时间复杂度和空间复杂度

时间复杂度为O(n)，同样空间复杂度也为O(n)，n为结点数。

3.2 广度优先遍历【层序遍历】

3.2.1 层序遍历

是从根节点开始到叶子节点，一层一层从左到右遍历各个节点。一层遍历完再遍历下一层。
因为每一层各个节点直接没有直接的关联，所以需要借助队列来实现层序遍历。
步骤：
1、根节点先进入队列，然后根节点出队，在根节点出队后，若根节点有左孩子节点和右孩子结点，再将根节点的根节点有左孩子节点和右孩子结点放入队列。
2、重复循环1，知道左孩子节点和右孩子节点没有孩子节点位置。

3.2.2 代码实现

package main

import "fmt"

type Node struct {
	Data  int
	Left  \*Node
	Right \*Node
}

//前序遍历
func PreOrder(node \*Node) {
	if node != nil {
		fmt.Print(" ", node.Data)
		PreOrder(node.Left)
		PreOrder(node.Right)
	}
}

//中序遍历
func InOrder(node \*Node) {
	if node != nil {
		InOrder(node.Left)
		fmt.Print(" ", node.Data)
		InOrder(node.Right)
	}
}

//后序遍历
func PostOrder(node \*Node) {
	if node != nil {
		PostOrder(node.Left)
		PostOrder(node.Right)
		fmt.Print(" ", node.Data)
	}
}

//层序遍历
func LevelOrder(root \*Node) [][]int {
	var res [][]int
	if root == nil {
		return nil
	}
	queue := []\*Node{root}
	for len(queue) > 0 {
		length := len(queue)
		var layer []int //每层的输出结果
		for i := 0; i < length; i++ {
			if queue[0].Left != nil {
				queue = append(queue, queue[0].Left)//相当于入队操作
			}

			if queue[0].Right != nil {
				queue = append(queue, queue[0].Right)//相当于入队操作
			}
			layer = append(layer, queue[0].Data)
			queue = queue[1:]//相当于出队操作，当把该节点的左右孩子放入队列中后就重新生成一个没有该节点的新切片，达到出队的目的
		}
		res = append(res, layer)
	}
	return res
}

func CreateTreeNode() \*Node { //p80
	node9 := &Node{
		Data:  9,
		Left:  nil,
		Right: nil,
	}

	node10 := &Node{
		Data:  10,
		Left:  nil,
		Right: nil,
	}

	node4 := &Node{
		Data:  4,
		Left:  nil,
		Right: nil,
	}

	node2 := &Node{
		Data:  2,
		Left:  node9,
		Right: node10,
	}

	node8 := &Node{
		Data:  8,
		Left:  nil,
		Right: node4,
	}

	node3 := &Node{
		Data:  3,
		Left:  node2,
		Right: node8,
	}
	return node3
}

func main() {
	rootNode := CreateTreeNode()
	//PreOrder(rootNode)
	//fmt.Println()
	//InOrder(rootNode)
	//fmt.Println()
	//PostOrder(rootNode)
	//fmt.Println()
	res := LevelOrder(rootNode)
	for i := 0; i < len(res); i++ {
		for j := 0; j < len(res[i]); j++ {
			fmt.Print(" ", res[i][j])
		}
	}
}

3.2.3 层序遍历的时间/空间复杂度

参考1：层序遍历的时间复杂度

时间复杂度：O(n)。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！