Day15 二叉树

SuperSwaggySUP

已于 2024-03-20 17:28:37 修改

阅读量418

点赞数 4

分类专栏： leetcode(一刷) 文章标签： java 数据结构

于 2024-03-20 17:23:07 首次发布

本文链接：https://blog.csdn.net/SuperSwaggy/article/details/136872296

版权

leetcode(一刷) 专栏收录该内容

38 篇文章 1 订阅

订阅专栏

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

层序遍历

107. 二叉树的层序遍历 II

状态：完成

思路：我这样写也可以做出来，最方便的办法肯定就是正向的层序遍历之后把答案翻转，还有一种不用翻转用LinkedList这个链表添加到头就行了。

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> list = new ArrayList<>();
        if(root==null) return list;
        Stack<TreeNode> stack=new Stack<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(queue.size()!=0){
            int size =queue.size();
            for(int i=0;i<size;i++){
                TreeNode temp =queue.poll();
                stack.push(temp);
                if(temp.right!=null) queue.add(temp.right);
                if(temp.left!=null) queue.add(temp.left);
            }
            stack.push(null);
        }
        stack.pop();
        while(stack.size()>0){
            List<Integer> tempList = new ArrayList<>();
            TreeNode node=stack.pop(); 
            while(node!=null){
                tempList.add(node.val);
                if(stack.size()==0) break;
                node=stack.pop();
            }
            list.add(tempList);
        }
        return list;
    }
}

199. 二叉树的右视图

状态：完成

思路：其实这题就是层序遍历的最后一个值的集合，所以只要把每一层的最后一个节点写进结果数组中就可以。

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

637. 二叉树的层平均值

状态：完成

思路：就是把每一层加起来除以每一层的个数

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        TreeNode node =root;
        List<Double> list = new ArrayList<>();
        if(root==null) return list;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        while(queue.size()>0){
            int size=queue.size();
            double sum=0;
            double nums=0;
            for(int i=0;i<size;i++){
                node=queue.poll();
                sum+=node.val;
                nums++;
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
            }
            list.add((double)sum/(double)nums);
        }
        return list;
    }
}

429. N 叉树的层序遍历

状态：完成

思路：把层序节点添加队列左右节点换成list的遍历

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> list=new ArrayList<>();
        if(root==null) return list;
        Queue<Node> queue=new LinkedList<>();
        queue.add(root);
        while(queue.size()>0){
            int size=queue.size();
            ArrayList<Integer> list2 = new ArrayList<>();
            for(int i=0;i<size;i++){
                Node node= queue.poll();
                for(Node a:node.children){
                    queue.add(a);
                }
                list2.add(node.val);
            }
            list.add(list2);
        }
        return list;
    }
}

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

状态：完成

思路：层序遍历中把每一行的最大值找到放进去

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> list=new ArrayList<>();
        if(root==null) return list;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        while(queue.size()>0){
            int size=queue.size();
            int max=Integer.MIN_VALUE;
            for(int i=0;i<size;i++){
                TreeNode node= queue.poll();
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
                max=max>node.val?max:node.val;
            }
            list.add(max);
        }
        return list;
    }
}

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

状态：完成

思路：在层序遍历过程中链接右节点就可以了。

class Solution {
    public Node connect(Node root) {
        List<List<Integer>> list=new ArrayList<>();
        if(root==null) return root;
        Queue<Node> queue=new LinkedList<>();
        queue.add(root);
        while(queue.size()>0){
            int size=queue.size();
            ArrayList<Integer> list2 = new ArrayList<>();
            Node node=null;
            for(int i=0;i<size;i++){
                if(node!=null){
                    node.next=queue.poll();
                    node= node.next;
                }else{
                    node=queue.poll();
                }
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
            }
        }
        return root;
    }
}

104. 二叉树的最大深度

状态：完成

思路：层序遍历算有多少层

class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        int index=0;
        while(queue.size()>0){
            int size=queue.size();
            for(int i=0;i<size;i++){
                TreeNode node= queue.poll();
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
            }
           index++;
        }
        return index;
    }
}

111. 二叉树的最小深度

状态：完成

思路：什么时候左右节点都是空的什么时候返回这时的层数+1。

class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        int index=0;
        while(queue.size()>0){
            int size=queue.size();
            for(int i=0;i<size;i++){
                TreeNode node= queue.poll();
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
                if(node.left==null&&node.right==null){
                    return index+1;
                }
            }
            index++;
        }
        return index;
    }
}

226. 翻转二叉树

层序遍历翻转二叉树：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null) return root;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        while(queue.size()>0){
            int size=queue.size();
            for(int i=0;i<size;i++){
                TreeNode node=queue.poll();
                TreeNode temp=node.left;
                node.left=node.right;
                node.right=temp;
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
            }
        }
        return root;
    }
}

前、后序翻转：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null) return root;
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}

中序翻转时此时的左节点是右节点所以遍历原先右节点时是现在左节点

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null) return root;
        
        invertTree(root.left);
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
        invertTree(root.left);
        return root;
    }
}

101. 对称二叉树

状态：层序遍历检测完成，后序遍历看讲解能理解意思

思路：层序遍历就是从层的两侧向中间去遍历，如果两侧的值不一样或者有空的值就肯定不是对称的。后序遍历感觉就是前序遍历的两个方向中左，中右这两个方向，周末休息的时候实现一下。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        List<List<Integer>> list=new ArrayList<>();
        if(root==null) return false;
        Queue<TreeNode> queue=new LinkedList<>();
        if(root.left!=null&&root.right!=null){
            queue.add(root.left);
            queue.add(root.right);
        }else{
            if(root.left==null&&root.right==null){
                return true;
            }
            return false;
        }
        while(queue.size()>0){
            int size=queue.size();
            for(int i=0;i<size/2;i++){
                TreeNode left=queue.poll();
                TreeNode right=queue.poll();
                if(left.val!=right.val) return false;
                if(left.left!=null&&right.right!=null){
                    queue.add(left.left);
                    queue.add(right.right);
                }
                if(left.left==null&&right.right!=null) return false;
                if(left.left!=null&&right.right==null) return false;
                
                if(left.right!=null&&right.left!=null){
                    queue.add(left.right);
                    queue.add(right.left);
                }
                if(left.right==null&&right.left!=null) return false;
                if(left.right!=null&&right.left==null) return false;
            }
        }
        return true;
    }
}

感想：二叉树之前没怎么做过，给我感觉挺灵活的，有时候没想到可以这样子做，而且很多数据结构也用到了二叉树，比如堆，周末我想总结一下java各个常用的数据结构的方法的时间复杂度。

SuperSwaggySUP

关注

4
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
Day15 二叉树

感想：二叉树之前没怎么做过，给我感觉挺灵活的，有时候没想到可以这样子做，而且很多数据结构也用到了二叉树，比如堆，周末我想总结一下java各个常用的数据结构的方法的时间复杂度。思路：层序遍历就是从层的两侧向中间去遍历，如果两侧的值不一样或者有空的值就肯定不是对称的。思路：我这样写也可以做出来，最方便的办法肯定就是正向的层序遍历之后把答案翻转，还有一种不用翻转用LinkedList这个链表添加到头就行了。思路：其实这题就是层序遍历的最后一个值的集合，所以只要把每一层的最后一个节点写进结果数组中就可以。
复制链接

扫一扫