二叉树的三种遍历实现(迭代法)

二叉树的三种遍历（不同迭代法实现）

前序遍历

二叉树的前序遍历

前序遍历的顺序是中左右，我们可以创建一个栈，利用栈的特性帮助我们前序遍历二叉树，先将二叉树的根节点入栈，再将根节点出栈，加入到结果集中，再将根节点的右子节点先入栈，左子节点再入栈，注意：空节点不入栈，再判断栈顶是否为空，为空则出栈，将出栈的节点加入到结果集中。为什么右子节点比左子节点先入栈，因为这样右子节点就比左子节点后出栈，节点出栈的顺序就是中左右了，正好和二叉树的前序遍历顺序一样。

Java代码如下：

class Solution {
    /**
     * 迭代法实现二叉树的前序遍历
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        // 声明一个动态数组存放结果
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.pop();
            res.add(node.val);
            // 注意右子节点比左子节点先入栈，这样出栈顺序就是中左右了
            // 将右子节点入栈
            if (node.right != null) {
                stack.push(node.right);
            }
            // 将左子节点入栈
            if (node.left != null) {
                stack.push(node.left);
            }
        }
        return res;
    }
}

中序遍历

二叉树的中序遍历

因为二叉树先访问的节点是中节点，而程序先处理的节点也是中节点，所以二叉树的前序遍历用迭代法实现比较简洁。

而中序遍历的迭代法就和前序遍历的迭代法有些不同，需要还借助一个指针帮助实现。

class Solution {
    /**
     * 迭代法实现二叉树的中序遍历，需要借助一个指针
     * @param root
     * @return
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        // 声明一个动态数组，用来存放结果
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root; // 先从根节点开始
        while (cur != null || !stack.isEmpty()) {
            // 如果cur == null，说明已找到最左子节点
            if (cur != null) {
                stack.push(cur);
                cur = cur.left; // 左
            } else {
                cur = stack.pop();
                res.add(cur.val); // 中
                cur = cur.right; // 右
            }
        }
        return res;
    }
}

后序遍历

二叉树的后序遍历

后序遍历的顺序是左右中，我们只需稍稍改变前序遍历的迭代法实现，得到遍历顺序为中右左的结果集，再将结果集翻转就可以得到后序遍历为左右中的结果集了。

class Solution {
    /**
     * 迭代法实现二叉树的后序遍历
     * 只需用迭代法得到中右左的结果集顺序，最后将结果集翻转即可
     * @param root
     * @return
     */
    public List<Integer> postorderTraversal(TreeNode root) {
        // 声明一个动态数组，用来存放结果
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root); // 先将根节点的值加入到栈中
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            res.add(node.val);
            // 将左子节点入栈
            if (node.left != null) {
                stack.push(node.left);
            }
            // 将右子节点入栈
            if (node.right != null) {
                stack.push(node.right);
            }
        }
        // 调用Collections类的reverse方法翻转res
        Collections.reverse(res);
        return res;
    }
}

二叉树的三种遍历（统一迭代法实现）

当要处理的节点放入栈中，可以再放入一个空节点做标记来实现

前序遍历

class Solution {
    /**
     * 统一迭代法得到二叉树的前序遍历结果
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        // 声明一个动态数组，用来存放结果
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root); // 先将根节点的值加入到栈中
        while (!stack.isEmpty()) {
            TreeNode node = stack.peek();
            if (node != null) {
                stack.pop();
                if (node.right != null) {
                    stack.push(node.right); // 右
                }
                if (node.left != null) {
                    stack.push(node.left); // 左
                }
                stack.push(node); // 中
                stack.push(null); // 空指针做标记
            } else {
                stack.pop();
                node = stack.pop();
                res.add(node.val);
            }
        }
        return res;
    }
}

中序遍历

class Solution {
    /**
     * 统一迭代法得到二叉树的中序遍历结果
     * @param root
     * @return
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        // 声明一个动态数组，用来存放结果
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root); // 先将根节点的值加入到栈中
        while (!stack.isEmpty()) {
            TreeNode node = stack.peek();
            if (node != null) {
                stack.pop();
                if (node.right != null) {
                    stack.push(node.right); // 右
                }
                stack.push(node); // 中
                stack.push(null); // 空指针做标记
                if (node.left != null) {
                    stack.push(node.left); // 左
                }
                
            } else {
                stack.pop();
                node = stack.pop();
                res.add(node.val);
            }
        }
        return res;
    }
}

后序遍历

class Solution {
    /**
     * 统一迭代法得到二叉树的后序遍历结果
     * @param root
     * @return
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        // 声明一个动态数组，用来存放结果
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root); // 先将根节点的值加入到栈中
        while (!stack.isEmpty()) {
            TreeNode node = stack.peek();
            if (node != null) {
                stack.pop();
                stack.push(node); // 中
                stack.push(null); // 空指针做标记
                if (node.right != null) {
                    stack.push(node.right); // 右
                }
                if (node.left != null) {
                    stack.push(node.left); // 左
                }
                
            } else {
                stack.pop();
                node = stack.pop();
                res.add(node.val);
            }
        }
        return res;
    }
}