二叉树的深度优先遍历算法实现

• 1. 二叉树的深度优先遍历简介
• 2. 算法实现
• • 2.1 二叉树的定义
  • 2.2 前序遍历
  • • 2.2.1 递归法
    • 2.2.2 迭代法
  • 2.3 中序遍历
  • • 2.3.1 递归法
    • 2.3.2 迭代法
  • 2.4 后序遍历
  • • 2.4.1 递归法
    • 2.4.2 迭代法
• 3. 复杂度分析
• 4. 结束语

定义：深度优先遍历也叫深度优先搜索，它属于图算法的一种，英文缩写为 DFS, 即 Depth First Search. 其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。

根据二叉树的递归定义可知，遍历一棵二叉树便要决定对根节点 N、左子树 L 和右子树 R 的访问顺序。对于深度优先遍历而言，按照先遍历左子树后遍历右子树的原则，可分为三种遍历算法，分别为：前序遍历、中序遍历和后序遍历。其中，“序” 指的是根节点被访问的次序。

二叉树可以采用顺序存储和链式存储两种方式，顺序存储就是用数组来存，链式存储则是使用指针来存。二叉树链式存储的定义代码如下(实现语言为 java)。

// Definition for a binary tree node.
public class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode() {}
     TreeNode(int val) { this.val = val; }
     TreeNode(int val, TreeNode left, TreeNode right) {
         this.val = val;
         this.left = left;
         this.right = right;
     }
}

前序遍历的递归操作过程如下。
若二叉树为空，则什么也不做，否则：

1. 访问根节点。
2. 前序遍历左子树。
3. 前序遍历右子树。

对应的递归算法如下。

List res = new linkedList<>();
void preTraversal(TreeNode root) {
	if (root == null) return;
    res.add(root.val);
    preTraversal(root.left);
    preTraversal(root.right);
}

前序遍历的迭代操作过程如下。

1. 沿着根的左子树依次入栈，入栈之前先访问左子树结点，直到左子树为空。
2. 栈顶元素出栈。若其右子树为空，继续执行 2.
3. 若其右子树不为空，将右子树转到 1 执行.

对应的迭代算法如下。

public List preorderTraversal(TreeNode root) {
    List res = new ArrayList<>();
    if (root == null) return res;
    Deque dq = new linkedList<>();
    TreeNode cur = root;
    while (!dq.isEmpty() || cur != null) {
    	// 不断将左子树入栈，直到左子树为空
        while (cur != null) {
            res.add(cur.val);   // 根
            dq.offer(cur);     
            cur = cur.left;     // 左
        }
        cur = dq.pollLast();
        cur = cur.right;       // 右
    }
    return res;
}

中序遍历的递归操作过程如下。
若二叉树为空，则什么也不做，否则：

1. 中序遍历左子树。
2. 访问根结点。
3. 中序遍历右子树。

对应的递归算法如下。

List res = new linkedList<>();
void midTraversal(TreeNode root) {
    if (root == null) return;
    midTraversal(root.left);
    res.add(root.val);
    midTraversal(root.right);
}

中序遍历的迭代操作过程如下：

1. 沿着根的左子树依次入栈，直到左子树为空。
2. 栈顶元素出栈并访问；若其右子树为空，继续执行 2.
3. 若其右孩子不为空，将右子树转到 1 执行。

对应的迭代算法如下：

public List inorderTraversal(TreeNode root) {
    List res = new ArrayList<>();
    if (root == null) return res;
    Deque dq = new linkedList<>();
    TreeNode cur = root;
    while (!dq.isEmpty() || cur != null) {
    	// 不断将左子树入栈，直到左子树为空
        while (cur != null) {  
            dq.offer(cur);
            cur = cur.left;  // 左         
        } 
       	cur = dq.pollLast();
        res.add(cur.val);   // 根
        cur = cur.right;    // 右
    }
    return res;
}

后序遍历的递归操作过程如下。
若二叉树为空，则什么也不做，否则：

1. 后序遍历左子树。
2. 后序遍历右子树。
3. 访问根节点。

对应的递归算法如下。

List res = new linkedList<>();
void postTraversal(TreeNode root) {
	if (root == null) return;
    postTraversal(root.left);
    postTraversal(root.right);
    res.add(root.val);
}

后序遍历的迭代操作过程如下。

1. 沿着根的左孩子依次入栈，直到左孩子为空。
2. 栈顶元素出栈，如果该结点有右子树，转到 1 执行。
3. 如果右子树为空或刚被访问完，则开始访问根结点。

对应的迭代算法如下。

public List postorderTraversal(TreeNode root) {
    List res = new ArrayList<>();
    if (root == null) return res;
    Deque dq = new linkedList<>();
    TreeNode pre = null;
    while (root != null || !dq.isEmpty()) {
        while (root != null) {
            dq.offer(root);
            root = root.left;  
        }
        root = dq.pollLast();
        if (root.right == null || root.right == pre) {
            res.add(root.val);  
            pre = root;
            root = null;
        } else {
            dq.offer(root);
            root = root.right;  
        }
    }
    return res;
}

时间复杂度：O(n), 其中 n 是二叉搜索树的节点数。每一个节点恰好被遍历一次。

空间复杂度：O(n), 为迭代过程中显式栈的开销，平均情况下为O(logn), 最坏情况下树呈现链状，为 O(n).

最后，可以通过力扣官网上面的题目练练手，它们分别是：

• 144. 二叉树的前序遍历
• 94. 二叉树的中序遍历
• 145. 二叉树的后序遍历