树——前序2(基本算法实现)

二叉树的基本算法

1. 先序遍历(中/后)
2. 层次遍历
3. 二叉树的深度

// 二叉树的定义
type linkNode struct{
    Val int
    left *linkNode
    right *linkNode
}

1、先序遍历二叉树

1.1 递归实现

// 前序遍历二叉树
func preorderTraversal(root *linkNode) []int {
	var res []int    // 用于结果的统计
	var dfs func(*linkNode)    
	dfs = func(root *linkNode) {    // 内置函数
		if root == nil {
			return
		}
		res = append(res, root.Val)    // 先序遍历，所以先添加头结点
		if root.Left != nil {
			dfs(root.Left)
		}
		if root.Right != nil {
			dfs(root.Right)
		}

	}
	dfs(root)
	return res
}

1.2 迭代实现

func preorderTraversal(root *linkNode) []int {
	var res []int         // 用于统计计算结果
	var stack []*linkNode // 定义栈 存储访问的元素

	if root == nil {
		return res
	}

	stack = append(stack, root)
	for len(stack) > 0 {
		node := stack[len(stack)-1]  // 获取栈顶元素
		stack = stack[:len(stack)-1] // 栈中弹出栈顶元素
		res = append(res, node.Val)  // 将弹出的元素加入res结果中

		if node.Right != nil { 		// 栈先进后出 所以先放入右结点
			stack = append(stack, node.Right)
		}
		if node.Left != nil { 		// 再放入左节点
			stack = append(stack, node.Left)
		}
	}
	return res
}

2 、层次遍历

2.1 迭代实现

// 层次遍历二叉树
func levelOrder(root *linkNode) []int {
	var res []int			// 定义结果集
	var queue []*linkNode	// 定义队列存储访问的元素
	if root == nil {
		return res
	}
	queue = append(queue, root)	

	for len(queue) > 0 {
		node := queue[0]    // 获取队列头元素
		queue = queue[1:]   // 删除队列头元素
		res = append(res, node.Val)
		if node.Left != nil {
			queue = append(queue, node.Left)
		}
		if node.Right != nil {
			queue = append(queue, node.Right)
		}
	}
	return res
}

3、二叉树的深度

3.1 递归(dfs)

// DFS

func maxDepth(root *linkNode) int {
	if root == nil {
		return 0
	}
	left := maxDepth(root.Left)
	right := maxDepth(root.Right)
	return max(left, right) + 1    // 根节点不为0时，深度已经+1
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

3.2 迭代实现

// 迭代
func maxDepth(root *linkNode) int {
	var depth int
	var queue []*linkNode

	if root == nil {
		return 0
	}

	queue = append(queue, root)
	for len(queue) > 0 {
		length := len(queue)
		for i := 0; i < length; i++ {     // 遍历完每层节点
			node := queue[0]
			queue = queue[1:]

			if node.Left != nil {
				queue = append(queue, node.Left)
			}
			if node.Right != nil {
				queue = append(queue, node.Right)
			}
		}
		depth += 1     // 相当于统计层数，每循环完一次，结果累计+1
	}
	return depth
}