LeetCode算法系列 144. 二叉树的前序遍历144. 二叉树的前序遍历给你二叉树的根节点 root ，返回它节

白菜Java自习室涵盖核心知识

LeetCode算法系列（Java版） 144. 二叉树的前序遍历
 LeetCode算法系列（Java版） 94. 二叉树的中序遍历
 LeetCode算法系列（Java版） 145. 二叉树的后序遍历

力扣原题

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的前序遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[1,2]

示例 5：

输入：root = [1,null,2]
输出：[1,2]

二叉树

二叉树是一种「数据结构」，简单来说，就是一个包含节点，以及它的左右孩子的一种数据结构。

遍历方式

如果对每一个节点进行编号，你会用什么方式去遍历每个节点呢？

1. 前序遍历

如果你按照 根节点 -> 左孩子 -> 右孩子 的方式遍历，即「先序遍历」，每次先遍历根节点，遍历结果为 1 2 4 5 3 6 7；

2. 中序遍历

如果你按照 左孩子 -> 根节点 -> 右孩子 的方式遍历，即「中序遍历」，遍历结果为 4 2 5 1 6 3 7；

3. 后序遍历

如果你按照 左孩子 -> 右孩子 -> 根节点 的方式遍历，即「后序遍历」，遍历结果为 4 5 2 6 7 3 1；

4. 层次遍历

「层次遍历」就是按照每一层从左向右的方式进行遍历，遍历结果为 1 2 3 4 5 6 7。

方法一：递归

思路与算法

二叉树的前序遍历：按照访问 根节点——左子树——右子树 的方式遍历这棵树，而在访问左子树或者右子树的时候，我们按照同样的方式遍历，直到遍历完整棵树。因此整个遍历过程天然具有递归的性质，我们可以直接用递归函数来模拟这一过程。

定义 preorder(root) 表示当前遍历到 root 节点的答案。按照定义，我们只要首先将 root 节点的值加入答案，然后递归调用 preorder(root.left) 来遍历 root 节点的左子树，最后递归调用 preorder(root.right) 来遍历 root 节点的右子树即可，递归终止的条件为碰到空节点。

代码实现

class Solution {

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preorder(root, res);
        return res;
    }

    public void preorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }
}

复杂度分析

时间复杂度： $O(n)$ ，其中 $n$ 是二叉树的节点数。每一个节点恰好被遍历一次。
空间复杂度： $O(n)$ ，为递归过程中栈的开销，平均情况下为 $O(\log n)$ ，最坏情况下树呈现链状，为 $O(n)$ 。

方法二：迭代

思路与算法

本质上是在模拟递归，因为在递归的过程中使用了系统栈，所以在迭代的解法中常用 Stack 来模拟系统栈。

首先我们应该创建一个 Stack 用来存放节点，首先我们想要打印根节点的数据，此时 Stack 里面的内容为空，所以我们优先将头结点加入 Stack ，然后打印。之后我们应该先打印左子树，然后右子树。所以先加入 Stack 的就是右子树，然后左子树。

代码实现

public static void preOrderIteration(TreeNode head) {
	if (head == null) {
		return;
	}
	Stack<TreeNode> stack = new Stack<>();
	stack.push(head);
	while (!stack.isEmpty()) {
		TreeNode node = stack.pop();
		System.out.print(node.value + " ");
		if (node.right != null) {
			stack.push(node.right);
		}
		if (node.left != null) {
			stack.push(node.left);
		}
	}
}

复杂度分析

时间复杂度： $O(n)$ ，其中 $n$ 是二叉树的节点数。每一个节点恰好被遍历一次。
空间复杂度： $O(n)$ ，为迭代过程中显式栈的开销，平均情况下为 $O(\log n)$ ，最坏情况下树呈现链状，为 $O(n)$ 。

LeetCode算法系列（Java版） 144. 二叉树的前序遍历
 LeetCode算法系列（Java版） 94. 二叉树的中序遍历
 LeetCode算法系列（Java版） 145. 二叉树的后序遍历