首页 > 编程语言> > 剑指offer一刷：搜索与回溯算法

剑指offer一刷：搜索与回溯算法

2022-05-07 12:31:27 作者：互联网

剑指 Offer 32 - I. 从上到下打印二叉树

难度：中等

方法一：层序遍历 BFS

题目要求的二叉树的从上至下打印（即按层打印），又称为二叉树的广度优先搜索（BFS）。

BFS 通常借助队列的先入先出特性来实现。

算法流程：

特例处理：当树的根节点为空，则直接返回空列表 []；
初始化：打印结果列表 res = []，包含根节点的队列 queue = [root]；
BFS 循环：当队列 queue 为空时跳出；
1. 出队：队首元素出队，记为 node；
2. 打印：将 node.val 添加至列表 tmp 尾部；
3. 添加子节点：若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue；
返回值：返回打印结果列表 res 即可。

class Solution {
    public int[] levelOrder(TreeNode root) {
        if(root == null) return new int[0];
        Queue<TreeNode> queue = new LinkedList<>(){{ add(root); }};
        ArrayList<Integer> ans = new ArrayList<>();
        while(!queue.isEmpty()) {
            TreeNode node = queue.poll();
            ans.add(node.val);
            if(node.left != null) queue.add(node.left);
            if(node.right != null) queue.add(node.right);
        }
        int[] res = new int[ans.size()];
        for(int i = 0; i < ans.size(); i++)
            res[i] = ans.get(i);
        return res;
    }
}

作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/9ab39g/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

时间复杂度：O(N)，空间复杂度：O(N)。

剑指 Offer 32 - II. 从上到下打印二叉树 II

难度：简单

方法一：层序遍历 BFS

在 I 的基础上，将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。

算法流程：

特例处理：当根节点为空，则返回空列表 []；
初始化：打印结果列表 res = []，包含根节点的队列 queue = [root]；
BFS 循环：当队列 queue 为空时跳出；
1. 新建一个临时列表 tmp，用于存储当前层打印结果；
2. 当前层打印循环：循环次数为当前层节点数（即队列 queue 长度）；
  1. 出队：队首元素出队，记为 node；
  2. 打印：将 node.val 添加至 tmp 尾部；
  3. 添加子节点：若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue；
3. 将当前层结果 tmp 添加入 res。
返回值：返回打印结果列表 res 即可。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) queue.add(root);
        while(!queue.isEmpty()) {
            List<Integer> tmp = new ArrayList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
            res.add(tmp);
        }
        return res;
    }
}

作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5v22om/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

时间复杂度：O(N)，空间复杂度：O(N)。

其中的 int i = queue.size(); 用的很妙，学习学习。

剑指 Offer 32 - III. 从上到下打印二叉树 III

难度：中等

方法一：层序遍历 + 双端队列

算法流程：

特例处理：当树的根节点为空，则直接返回空列表 []；
初始化：打印结果空列表 res，包含根节点的双端队列 deque；
BFS 循环：当 deque 为空时跳出；
1. 新建列表 tmp，用于临时存储当前层打印结果；
2. 当前层打印循环：循环次数为当前层节点数（即 deque 长度）；
  1. 出队：队首元素出队，记为 node；
  2. 打印：若为奇数层，将 node.val 添加至 tmp 尾部；否则，添加至 tmp 头部；
  3. 添加子节点：若 node 的左（右）子节点不为空，则加入 deque；
3. 将当前层结果 tmp 转化为 list 并添加入 res；
返回值：返回打印结果列表 res 即可；

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) queue.add(root);
        while(!queue.isEmpty()) {
            LinkedList<Integer> tmp = new LinkedList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                if(res.size() % 2 == 0) tmp.addLast(node.val);
                else tmp.addFirst(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
            res.add(tmp);
        }
        return res;
    }
}

作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5vve57/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

时间复杂度：O(N)，空间复杂度：O(N)。

方法二：层序遍历 + 双端队列（奇偶逻辑分离）

方法一代码简短、容易实现；但需要判断每个节点的所在层奇偶性，即冗余了 N 次判断。
通过将奇偶层逻辑拆分，可以消除冗余的判断。

算法流程：

BFS 循环：循环打印奇 / 偶数层，当 deque 为空时跳出；
1. 打印奇数层：从左向右打印，先左后右加入下层节点；
2. 若 deque 为空，说明向下无偶数层，则跳出；
3. 打印偶数层：从右向左打印，先右后左加入下层节点；

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) deque.add(root);
        while(!deque.isEmpty()) {
            // 打印奇数层
            List<Integer> tmp = new ArrayList<>();
            for(int i = deque.size(); i > 0; i--) {
                // 从左向右打印
                TreeNode node = deque.removeFirst();
                tmp.add(node.val);
                // 先左后右加入下层节点
                if(node.left != null) deque.addLast(node.left);
                if(node.right != null) deque.addLast(node.right);
            }
            res.add(tmp);
            if(deque.isEmpty()) break; // 若为空则提前跳出
            // 打印偶数层
            tmp = new ArrayList<>();
            for(int i = deque.size(); i > 0; i--) {
                // 从右向左打印
                TreeNode node = deque.removeLast();
                tmp.add(node.val);
                // 先右后左加入下层节点
                if(node.right != null) deque.addFirst(node.right);
                if(node.left != null) deque.addFirst(node.left);
            }
            res.add(tmp);
        }
        return res;
    }
}

作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5vve57/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

时间复杂度：O(N)，空间复杂度：O(N)。

方法三：层序遍历 + 倒序

此方法的优点是只用列表即可，无需其他数据结构。
偶数层倒序：若 res 的长度为奇数，说明当前是偶数层，则对 tmp 执行倒序操作。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) queue.add(root);
        while(!queue.isEmpty()) {
            List<Integer> tmp = new ArrayList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
            if(res.size() % 2 == 1) Collections.reverse(tmp);
            res.add(tmp);
        }
        return res;
    }
}

作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5vve57/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

时间复杂度：O(N)，空间复杂度：O(N)。

标签：node,tmp,offer,res,打印,queue,add,一刷,回溯
来源： https://www.cnblogs.com/CWZhou/p/16241971.html