二叉树的迭代怎么写

大家好，我是三叔，很高兴这期又和大家见面了，一个奋斗在互联网的打工人。

笔者在二叉树的递归遍历中介绍过二叉树用递归的方法去深度优先搜索，本篇博客，笔者将教大家二叉树的迭代法如何写。

前序遍历迭代法

/**
 * 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;
 *     }
 * }
 */
class Solution {// 迭代法写出二叉树的前序遍历
    public List<Integer> preorderTraversal(TreeNode root) {
        // 迭代法实现前序遍历，深度优先搜索，底层是使用栈实现的
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> result = new ArrayList<>();
        if(root == null) {
            return result; 
        }
         stack.push(root);
        // 先让根节点入栈
        while(!stack.isEmpty()) {// 栈不为空，进行迭代操作
            // 弹出树
            TreeNode node = stack.pop();
            result.add(node.val);
            // 栈先进后出，前序遍历：中左右  ——》右先入栈，左再入栈，弹出的就是左元素
            if(node.right != null) {
                stack.push(node.right);
            }
            if(node.left != null) {
                stack.push(node.left);
            }     
        }
        return result;
    }
}

中序遍历的迭代法

/**
 * 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;
 *     }
 * }
 */
 // 中序遍历：迭代法 左中右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null) {
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()) {
           if(cur != null) {
               stack.push(cur);
               cur = cur.left;
           } else { // 当指针cur的左边孩子为空的时候
                cur = stack.pop();
                result.add(cur.val);
                cur = cur.right;// 现在去找它的右孩子
           }
        }
        return result;

    }
}

后序遍历迭代法

/**
 * 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;
 *     }
 * }
 */
 // 迭代法写后序遍历，底层实现还是栈，所以需要new一个栈
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        // 后序遍历  左右中 -》 中左右替换位置：中右左-》反转左右中
        List<Integer> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root == null) {
            return result;
        }
        // 根节点入栈
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.pop();
            int res = node.val;
            result.add(res);
            if(node.left != null) {
                stack.push(node.left);
            }

            if(node.right != null) {
                stack.push(node.right);
            }
        }
        // 反转list
        Collections.reverse(result);
        return result;
    }
}

总结

递归遍历和迭代遍历都是遍历二叉树的方法，但它们的实现方式有所不同。递归遍历使用函数的递归调用来处理节点，而迭代遍历使用循环和栈（或队列）来处理节点。

递归遍历相对简单，易于理解和编写，但可能存在函数调用的开销和堆栈溢出的风险。迭代遍历需要手动模拟递归过程，可能会更复杂一些，但可以避免函数调用的开销和堆栈溢出的风险。