剑指Offer题目笔记13（二叉树的广度优先搜索）

勤恳的小码农

已于 2024-03-24 12:49:22 修改

阅读量253

点赞数 5

文章标签：笔记 java 广度优先数据结构算法

于 2024-03-20 20:23:37 首次发布

本文链接：https://blog.csdn.net/weixin_68854858/article/details/136887706

版权

面试题43：

面试题43

问题：

实现数据结构CBTInserter的三种方法。
CBTInserter(TreeNode root) 使用头节点为 root 的给定树初始化该数据结构。
CBTInserter.insert(int v) 向树中插入一个值为 Node.val == val的新节点 TreeNode。使树保持完全二叉树的状态，并返回插入节点TreeNode的父节点的值。
CBTInserter.get_root()将返回树的头节点。

解决方案：

实现在完全二叉树中添加新节点，使用队列作为数据容器。先将头节点存入队列，然后从上到下按层从左到右扫描，找出第一个左节点或右节点存在空缺的节点，如果它缺少左节点，那么新节点就是它的左节点，如果它缺少右节点，那么新节点就是它的右节点，如果它的左右节点都不在空缺，那么就将该节点移除队列，将它的左右节点存入队列。

源代码：

/**
 * 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 CBTInserter {
    private Queue<TreeNode> queue;
    private TreeNode root;

    public CBTInserter(TreeNode root) {
        this.root = root;
        queue = new LinkedList<>();
        if(root != null){
            queue.offer(root);
        }
        while(queue.peek().left != null && queue.peek().right != null){
            TreeNode node = queue.poll();
            queue.offer(node.left);
            queue.offer(node.right);
        }
    }
    
    public int insert(int val) {
        TreeNode oldNode = queue.peek();
        TreeNode newNode = new TreeNode(val);
        if(queue.peek().left == null){
            queue.peek().left = newNode;
        }else if(queue.peek().right == null){
            queue.peek().right = newNode;

            queue.poll();
            queue.offer(oldNode.left);
            queue.offer(oldNode.right);
        }
        return oldNode.val;
    }
    
    public TreeNode get_root() {
        return root;
    }
}

面试题44：

面试题44

第一种方法（用一个队列实现二叉树的广度优先搜索）：

问题：

输入一棵二叉树，找出二叉树中每层的最大值。

解决方案：

使用队列作为数据容器。扫描二叉树时将节点存入队列中，但是我们不能确定每层是什么时候开始或者什么时候结束的，所以我们使用两个变量分别记录两层的节点的数目，变量current来存储当前二叉树层的节点数目，变量next来存储当前二叉树下一层的节点数目。

源代码：

/**
 * 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> largestValues(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        int current = 0;
        int next = 0;
        if(root != null){
            current = 1;
            queue.offer(root);
        }
        List<Integer> result = new ArrayList<>();
        int max = Integer.MIN_VALUE;
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            max = Math.max(max,node.val);
            current--;

            if(node.left != null){
                queue.offer(node.left);
                next++;
            }
            if(node.right != null){
                queue.offer(node.right);
                next++;
            }
            //当前二叉树层的结束
            if(current == 0){
                result.add(max);
                max = Integer.MIN_VALUE;
                current = next;
                next = 0;
            }
        }
        return result;
    }
}

第二种方法（用两个队列实现二叉树的广度优先搜索）

思路：

将不同层的节点放入不同的队列中。创建两个队列queue1，queue2，queue1只放入当前扫描层的节点，而queue2只放入当前扫描的下一层的节点。当queue1为空时，记录当前层节点的最大值，并将queue1指向queue2，queue2重新初始化为空的队列。

源代码：

/**
 * 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> largestValues(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        if(root != null){
            queue1.offer(root);
        }
        List<Integer> list = new ArrayList<>();
        int max = Integer.MIN_VALUE;
        while(!queue1.isEmpty()){
            TreeNode node = queue1.poll();
            max = Math.max(max,node.val);

            if(node.left != null){
                queue2.offer(node.left);
            }
            if(node.right != null){
                queue2.offer(node.right);
            }
            if(queue1.isEmpty()){
                list.add(max);
                max = Integer.MIN_VALUE;
                queue1 = queue2;
                queue2 = new LinkedList<>();
            }
        }
        return list;
    }
}

面试题45：

面试题45

问题：

找出一棵二叉树中找出它最低层最左边节点的值。

解决方案：

使用队列作为数据容器，创建两个队列queue1、queue2，queue1只放入当前扫描层的节点，而queue2只放入当前扫描的下一层的节点。当queue1为空时，将queue1指向queue2，并将queue2重新初始化为空的队列，此时记录当前queue1最前面的节点就是每层最左边节点。

源代码：

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        int left = 0;
        if(root != null){
            queue1.offer(root);
            left = root.val;
        }
        while(!queue1.isEmpty()){
            TreeNode node = queue1.poll();

            if(node.right != null){
                queue2.offer(node.right);
                left = node.right.val;
            }
            if(node.left != null){
                queue2.offer(node.left);
                left = node.left.val;
            }  
            if(queue1.isEmpty()){
                queue1 = queue2;
                queue2 = new LinkedList<>();
            }
        }
        return left;
    }
}

面试题46：

面试题46

问题：

站在二叉树的右边，返回从上到下看到的节点。

解决方案：

使用队列作为数据容器，创建两个队列queue1、queue2，queue1只放入当前扫描层的节点，而queue2只放入当前扫描的下一层的节点。当queue1为空时，此时记录当前queue1最后面的节点就是每层最右边的节点，将queue1指向queue2，并将queue2重新初始化为空的队列。

源代码：

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        List<Integer> rightList = new ArrayList<>();
        if(root == null){
            return rightList;   
        }
        queue1.offer(root);
        while(!queue1.isEmpty()){
            TreeNode node = queue1.poll();
            
            if(node.left != null){
                queue2.offer(node.left);
            }
            if(node.right != null){
                queue2.offer(node.right);
            }
            if(queue1.isEmpty()){
                rightList.add(node.val);
                queue1 = queue2;
                queue2 = new LinkedList<>();
            }
        }
        return rightList;
    }
}