代码随想录day15(二叉树的层序遍历(BFS-广度优先搜索))

于 2024-03-20 16:39:55 发布
阅读量761 收藏
点赞数 30
文章标签： leetcode java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60994484/article/details/136867935
版权

代码随想录day15

102.二叉树的层序遍历

数组

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null){
            return new ArrayList<List<Integer>>();
        }

        queue.add(root);    //根节点
        while(queue.size() > 0){
            int size =  queue.size();     //获取队列长度
            ArrayList<Integer> tmp = new ArrayList<Integer>();
            //遍历树，将每层节点先放入queue中，然后放入tmp中
            for(int i = 0; i < size; i++){
                TreeNode t = queue.remove();
                tmp.add(t.val);
                if(t.left != null){
                    queue.add(t.left);
                }
                if(t.right != null){
                    queue.add(t.right);
                }
            }
            list.add(tmp);
        }

        return list;  
    }
}

队列

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) return List.of();
        List<List<Integer>> list = new ArrayList<>();
        Queue<TreeNode> q = new ArrayDeque<>();
        q.add(root);
        while (!q.isEmpty()) {
            int n = q.size();
            List<Integer> vals = new ArrayList<>(n); 
            while (n-- > 0) {
                TreeNode node = q.poll();
                vals.add(node.val);
                if (node.left != null){ 
                    q.add(node.left);
                }
                if (node.right != null){
                    q.add(node.right);
                }
            }
            list.add(vals);
        }
        return list;
    }
}

107.二叉树的层序遍历II

在层序遍历的结果添加一个反转

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {

 List<List<Integer>> list = new ArrayList<List<Integer>>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null){
            return new ArrayList<List<Integer>>();
        }

        queue.add(root);    //根节点
        while(queue.size() > 0){
            int size =  queue.size();     //获取队列长度
            ArrayList<Integer> tmp = new ArrayList<Integer>();
            //遍历树，将每层节点先放入queue中，然后放入tmp中
            for(int i = 0; i < size; i++){
                TreeNode t = queue.remove();
                tmp.add(t.val);
                if(t.left != null){
                    queue.add(t.left);
                }
                if(t.right != null){
                    queue.add(t.right);
                }
            }

            list.add(tmp);
        }
        //反转
        Collections.reverse(list);
        return list;  
    }
}

199.二叉树的右视图

在层序遍历的基础上加一个list中每次放入的是我们每层的最后一个元素

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null){
            return list;
        }

        queue.add(root);
       while(queue.size() > 0){
            int size =  queue.size();     //获取队列长度
            //遍历树，将每层节点先放入queue中，然后放入tmp中
            for(int i = 0; i < size; i++){
                TreeNode t = queue.remove();
                if(t.left != null){
                    queue.add(t.left);
                }
                if(t.right != null){
                    queue.add(t.right);
                }
                if(i == size-1){
                    list.add(t.val);
                }
            }
        }
        return list;
    }
}

637.二叉树的平均值

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> list = new ArrayList<>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null){
            return list;
        }

        queue.add(root);
       while(queue.size() > 0){
            int size =  queue.size();     //获取队列长度
            double sum = 0;
            //遍历树，将每层节点先放入queue中，然后放入tmp中
            for(int i = 0; i < size; i++){
                TreeNode t = queue.remove();
                sum += t.val;
                if(t.left != null){
                    queue.add(t.left);
                }
                if(t.right != null){
                    queue.add(t.right);
                }
            }
            list.add(sum / size);
        }
        return list;
    }
}

429.N叉树的层序遍历

把访问左右子树改成遍历孩子节点列表。

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        LinkedList<Node> queue = new LinkedList<Node>();
        if(root == null){
            return new ArrayList<List<Integer>>();
        }

        queue.add(root);    //根节点
        while(queue.size() > 0){
            int size =  queue.size();     //获取队列长度
            ArrayList<Integer> tmp = new ArrayList<Integer>();
            //遍历树，将每层节点先放入queue中，然后放入tmp中
            for(int i = 0; i < size; i++){
                Node t = queue.remove();
                tmp.add(t.val);
                List<Node> children = t.children;
                //排除孩子节点为空
                if(children == null || children.size() == 0){
                    continue;
                }
                for(Node child : children){
                    if(chile != null){
                        queue.add(child);
                    }
                }
            }
            list.add(tmp);
        }

        return list;  
    }
}

515.在每个树行中找最大值

在层序遍历的基础上，给每层返回时添加一个判断最大值

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null){
            return list;
        }

        queue.add(root);
       while(queue.size() > 0){
            //使用MIN_VALUE确保第一次判断大小的节点可以进入max中
            int max= Integer.MIN_VALUE;
            int size =  queue.size();     //获取队列长度
            //遍历树，将每层节点先放入queue中，然后放入tmp中
            for(int i = 0; i < size; i++){
                TreeNode t = queue.remove();
                max = Math.max(t.val,max);
                if(t.left != null){
                    queue.add(t.left);
                }
                if(t.right != null){
                    queue.add(t.right);
                }
            }
            list.add(max);
        }
        return list;
    }
}

116. 填充每个节点的下一个右侧节点指针

在层序遍历的基础上添加一个在一层链接下一个的指针

class Solution {
    public Node connect(Node root) {
        List<Node> pre = new ArrayList<>();
        pre.add(root);
        if(root == null){
            return null;
        }
        while(!pre.isEmpty()){
            List<Node> tmp = pre;
            pre = new ArrayList<>();
            for(int i=0 ; i<tmp.size() ; i++){
                Node node = tmp.get(i);
                //同一层
                if(i > 0){
                    tmp.get(i-1).next = node;
                }
                if(node.left != null){
                    pre.add(node.left);
                }
                if(node.right != null){
                    pre.add(node.right);
                }
            }
        }
        return root;
        
    }
}

117.填充每个节点的下一个右侧节点指针II

class Solution {
    public Node connect(Node root) {
        List<Node> pre = new ArrayList<>();
        pre.add(root);
        if(root == null){
            return null;
        }
        while(!pre.isEmpty()){
            List<Node> tmp = pre;
            pre = new ArrayList<>();
            for(int i=0 ; i<tmp.size() ; i++){
                Node node = tmp.get(i);
                //同一层
                if(i > 0){
                    tmp.get(i-1).next = node;
                }
                if(node.left != null){
                    pre.add(node.left);
                }
                if(node.right != null){
                    pre.add(node.right);
                }
            }
        }
        return root;
        
    }
}

104.二叉树的最大深度

在层序遍历的基础上添加一个记录遍历了几层的计数器

class Solution {
    public int maxDepth(TreeNode root) {
      List<TreeNode> pre = new ArrayList<>();
        pre.add(root);
        if(root == null){
            return 0;
        }
        int num = 0;
        while(!pre.isEmpty()){
            List<TreeNode> tmp = pre;
            pre = new ArrayList<>();
            for(int i=0 ; i<tmp.size() ; i++){
                TreeNode node = tmp.get(i);
                if(node.left != null){
                    pre.add(node.left);
                }
                if(node.right != null){
                    pre.add(node.right);
                }
            }
            num++;
        }
        return num;
    }
}

111.二叉树的最小深度

在上一题的基础上添加一个判断条件：
若有一个节点的左右孩子节点均为空时
	直接返回此时记录的深度

class Solution {
    public int minDepth(TreeNode root) {
       List<TreeNode> pre = new ArrayList<>();
        pre.add(root);
        if(root == null){
            return 0;
        }
        int num = 0;
        while(!pre.isEmpty()){
            num++;
            List<TreeNode> tmp = pre;
            pre = new ArrayList<>();
            for(int i=0 ; i<tmp.size() ; i++){
                TreeNode node = tmp.get(i);
                if(node.left == null && node.right == null){
                    return num;
                }
                if(node.left != null){
                    pre.add(node.left);
                }
                if(node.right != null){
                    pre.add(node.right);
                }
            }
            
        }
        return num;
    }
}

226.翻转二叉树

在层序遍历的基础上增加一个反转的部分


class Solution {
    public TreeNode invertTree(TreeNode root) {
        List<TreeNode> pre = new ArrayList<>();
        pre.add(root);
        if(root == null){
            return null;
        }
        while(!pre.isEmpty()){
            List<TreeNode> tmp = pre;
            pre = new ArrayList<>();
            for(int i=0 ; i<tmp.size() ; i++){
                TreeNode node = tmp.get(i);
                if(node.left != null){
                    pre.add(node.left);
                }
                if(node.right != null){
                    pre.add(node.right);
                }
                
                //反转
                TreeNode temp = node.left;
                node.left = node.right;
                node.right = temp;
                
            }
            
        }
        return root;
    }
}

101.对称二叉树

在判断二叉树是否对称我们比对的是外侧与外侧，内侧与内侧

class Solution {
    public boolean isSymmetric(TreeNode root) {
        LinkedList<TreeNode> pre = new LinkedList<TreeNode>();
        pre.add(root.left);
        pre.add(root.right);
        if(root == null){
            return true;
        }
        while(!pre.isEmpty()){
            TreeNode leftNode = pre.removeFirst();
            TreeNode rightNode = pre.removeFirst();
            if(leftNode == null && rightNode == null){
                continue;
            }
            if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
                return false;
            }

            pre.add(leftNode.left);
            pre.add(rightNode.right);
            pre.add(leftNode.right);
            pre.add(rightNode.left);
        }
        return true;
    }
}
昨日的誓言
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值