【LeetCode】二叉树的遍历——代码随想录算法训练营Day14

144. 二叉树的前序遍历

94. 二叉树的中序遍历

145. 二叉树的后序遍历

一、递归遍历

文章讲解：代码随想录

视频讲解：每次写递归都要靠直觉？ 这次带你学透二叉树的递归遍历！| LeetCode：144.前序遍历，145.后序遍历，94.中序遍历_哔哩哔哩_bilibili

1. 前序遍历

遍历顺序：中左右。

递归分析：

• 确定递归函数的参数和返回值：参数为当前正在遍历的节点，返回值为 void。
• 确定终止条件：当前遍历的节点为空，返回。
• 确定单层递归的逻辑：以中左右的顺序，先遍历当前节点，再递归的遍历左子树，然后递归的遍历右子树。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var preorderTraversal = function(root) {
    const res = [];
    function preorder(node) {
        if (!node) {
            return;
        }
        res.push(node.val); // 遍历当前节点
        preorder(node.left); // 递归的遍历左子树
        preorder(node.right); // 递归的遍历右子树
    }
    preorder(root);
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(logn)。

2. 中序遍历

遍历顺序：左中右。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var inorderTraversal = function(root) {
    const res = [];
    function inorder(node) {
        if (!node) {
            return;
        }
        inorder(node.left); // 递归的遍历左子树
        res.push(node.val); // 遍历当前节点
        inorder(node.right); // 递归的遍历右子树
    }
    inorder(root);
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(logn)。 

3. 后序遍历

遍历顺序：左右中。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var postorderTraversal = function(root) {
    const res = [];
    function postorder(node) {
        if (!node) {
            return;
        }
        postorder(node.left); // 递归的遍历左子树
        postorder(node.right); // 递归的遍历右子树
        res.push(node.val); // 遍历当前节点
    }
    postorder(root);
    return res;
};

 分析：时间复杂度为 O(n)，空间复杂度为 O(logn)。

二、非递归遍历——迭代遍历

文章讲解：代码随想录

视频讲解：写出二叉树的非递归遍历很难么？这次让你不再害怕非递归！|二叉树的非递归遍历 | 二叉树的遍历迭代法 | 前序与中序_哔哩哔哩_bilibili

1. 前序遍历

思路：使用栈模拟递归解法，先遍历当前节点，再将右孩子压入栈中，再将左孩子压入栈中，这样出栈时就是左孩子先出来，右孩子再出来，符合前序遍历的中左右的顺序。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var preorderTraversal = function(root) {
    const res = [];
    const stack = [];
    if (root) {
        stack.push(root);
    }
    while (stack.length > 0) {
        const node = stack.pop();
        res.push(node.val); // 中
        node.right && stack.push(node.right); // 右
        node.left && stack.push(node.left); // 左
    }
    return res;
};

分析：时间复制度为 O(n)，空间复制度为 O(logn)。

2. 后序遍历

思路：前序遍历的顺序是中左右，将前序遍历代码中右和左的顺序交换一下就成了中右左，最后再将结果数组翻转即得到左右中，即后续遍历得顺序。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var postorderTraversal = function(root) {
    const res = [];
    const stack = [];
    if (root) {
        stack.push(root);
    }
    while (stack.length > 0) {
        const node = stack.pop();
        res.push(node.val); // 中
        node.left && stack.push(node.left); // 左
        node.right && stack.push(node.right); // 右
    }
    return res.reverse(); // 反转结果数组
};

分析：时间复制度为 O(n)，空间复制度为 O(logn)。

3. 中序遍历

思路：对于前序遍历和后续遍历的非递归写法中，访问元素和处理元素的顺序都是一样的，因此可以通过交换关键代码顺序由前序遍历变为后序遍历。而中序遍历访问元素和处理元素的顺序是不一样的，不是同时进行的，因此写法会和前序遍历和后序遍历不一样。

可以定义一个指针用来访问二叉树的节点，访问的同时将节点压入栈中，一路向左访问，直到左孩子为空时，处理节点，然后访问右孩子。在访问的节点和栈都为空时结束遍历，符合中序遍历左中右的顺序。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var inorderTraversal = function(root) {
    const res = [];
    const stack = [];
    let cur = root; // 访问节点
    while (cur || stack.length > 0) {
        if (cur) {
            stack.push(cur); // 将访问过的节点压入栈中
            cur = cur.left; // 左
        } else {
            cur = stack.pop();
            res.push(cur.val); // 中 处理节点
            cur = cur.right; // 右
        }
    }
    return res;
};

分析：时间复制度为 O(n)，空间复制度为 O(logn)。

三、迭代遍历的统一写法

文章讲解：代码随想录

上面的二叉树三种顺序遍历的迭代遍历写法代码风格并不统一，中序遍历的写法和前序后序完全不一样。不像递归法，代码写法风格统一，更换核心代码顺序就能从前序遍历改为中序遍历和后续遍历。

上面中序遍历中，使用栈无法解决访问元素和处理元素不一致的问题。可以将访问的节点放入栈中，要处理的节点也放入栈中但要进行标记，可以使用空指针作为标记。这种方法称为标记法。

1. 中序遍历

先来看中序遍历，遍历过程中把访问过的元素以右中左的顺序放入栈中，中间元素后加入一个空指针作为标记。当遇到空指针表示前一个元素就是要处理的元素，就将前面的元素弹出并处理。

• 遍历顺序：左中右
• 入栈顺序：右中左

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var inorderTraversal = function(root) {
    const res = [];
    const stack = [];
    if (root) {
        stack.push(root);
    }
    while (stack.length > 0) {
        const node = stack.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
        if (node) {
            node.right && stack.push(node.right); // 右
            stack.push(node); // 中
            stack.push(null); // 标记
            node.left && stack.push(node.left); // 左
        } else {
            res.push(stack.pop().val); // 空节点已经在 if 上面那行代码中弹出，此时再弹出的节点即为要处理的节点
        }
        
    }
    return res;
};

分析：时间复制度为 O(n)，空间复制度为 O(logn)。

2. 前序遍历

• 遍历顺序：中左右
• 入栈顺序：右左中

调整中序遍历核心代码的顺序，将入栈顺序调整为右左中，即可变为前序遍历。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var preorderTraversal = function(root) {
    const res = [];
    const stack = [];
    if (root) {
        stack.push(root);
    }
    while (stack.length > 0) {
        const node = stack.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
        if (node) {
            node.right && stack.push(node.right); // 右
            node.left && stack.push(node.left); // 左
            stack.push(node); // 中
            stack.push(null); // 标记
        } else {
            res.push(stack.pop().val); // 空节点已经在 if 上面那行代码中弹出，此时再弹出的节点即为要处理的节点
        }
        
    }
    return res;
};

分析：时间复制度为 O(n)，空间复制度为 O(logn)。

3. 后续遍历

• 遍历顺序：左右中
• 入栈顺序：中右左

调整中序遍历核心代码的顺序，将入栈顺序调整为中右左，即可变为后序遍历。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var postorderTraversal = function(root) {
    const res = [];
    const stack = [];
    if (root) {
        stack.push(root);
    }
    while (stack.length > 0) {
        const node = stack.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
        if (node) {
            stack.push(node); // 中
            stack.push(null); // 标记
            node.right && stack.push(node.right); // 右
            node.left && stack.push(node.left); // 左
        } else {
            res.push(stack.pop().val); // 空节点已经在 if 上面那行代码中弹出，此时再弹出的节点即为要处理的节点
        }
        
    }
    return res; // 反转结果数组
};

分析：时间复制度为 O(n)，空间复制度为 O(logn)。