二叉树的迭代遍历板子

BFS

• 找距离某一点的最短路，但路径不唯一，最先搜索到满足条件的就是最短的路径
• 大范围的查找
• 出现 “最短”、“最少”类似字眼的可以优先考虑 性质：

1. 新加入的结点到根的距离一定大于等于队列中排在它前面的结点。也就是说，BFS天然地带有路径长度的信息，可以依次搜索到走一步可到达的点，走两步可到达的点，走三步可到达的点…
2. 搜索是以接近起始状态的程序依次扩展状态的
3. 只对每个节点访问一遍
4. BFS关键点是状态的选取和标记

DFS

• 目的性强的查找与搜索问题，白话就是：能找出解就行
• 是否可达问题 性质：

3. 搜索是以接近起始状态的程序依次扩展状态的
4. DFS的重要点在于状态回溯（树用DFS遍历时不需要回溯，因为每一个结点只能有唯一一条从上一个结点来的路径；图用DFS遍历时需要回溯，即再把visit[i]置为0，因为可能有多条从上一个结点的路径）

———————————————— 版权声明：本文为CSDN博主「咕咕酱没有悲伤」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：blog.csdn.net/weixin_4484…

• 前序

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans=new ArrayList<>();
        LinkedList<TreeNode> stack=new LinkedList<>();
        if(root!=null) stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node=stack.pop();
            if(node!=null){
                if(node.right!=null) stack.push(node.right);
                if(node.left!=null) stack.push(node.left);
                stack.push(node);
                stack.push(null);
            }else{
                ans.add(stack.pop().val);
            }
        }
        return ans;
    }
}

• 中序

List<Integer> ans=new ArrayList<>();
        LinkedList<TreeNode> stack=new LinkedList<>();
        if(root!=null) stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node=stack.pop();
            if(node!=null){
                if(node.right!=null) stack.push(node.right);
                stack.push(node);
                stack.push(null);
                if(node.left!=null) stack.push(node.left);
            }else{
                ans.add(stack.pop().val);
            }
        }
        return ans;

• 后序

List<Integer> ans=new ArrayList<>();
        LinkedList<TreeNode> stack=new LinkedList<>();
        if(root!=null) stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node=stack.pop();
            if(node!=null){
                stack.push(node);
                stack.push(null);
                if(node.right!=null) stack.push(node.right);
                if(node.left!=null) stack.push(node.left);
            }else{
                ans.add(stack.pop().val);
            }
        }
        return ans;

• 层序BFS

// 102.二叉树的层序遍历
class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {      
        checkFun02(root);
        return resList;
    }
    //BFS--迭代方式--借助队列
    public void checkFun02(TreeNode node) {
        if (node == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);

        while (!que.isEmpty()) {
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();

            while (len > 0) {
                TreeNode tmpNode = que.poll();
                itemList.add(tmpNode.val);

                if (tmpNode.left != null) que.offer(tmpNode.left);
                if (tmpNode.right != null) que.offer(tmpNode.right);
                len--;
            }

            resList.add(itemList);
        }

    }
}