代码随想录算法训练营第十五天| 层序遍历 ，226.翻转二叉树 ，101.对称二叉树

已于 2024-03-06 12:18:30 修改
阅读量176 收藏 5
点赞数 6
分类专栏： 代码随想录算法训练营 文章标签： 算法
于 2024-03-06 11:29:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43385261/article/details/136495759
版权

代码随想录算法训练营

今日任务
层序遍历 ，226.翻转二叉树 ，101.对称二叉树

文章目录

层序遍历

102.二叉树的层序遍历

/**
 * 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<List<Integer>> levelOrder(TreeNode root) {
        //层序遍历，借助队列
        List<List<Integer>> result=new ArrayList<>();
        //创造一个队列
        Queue<TreeNode> queue=new LinkedList<>();
        //树为空，直接返回
        if(root==null){
            return result;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list=new ArrayList<>();
            while(size>0){
                TreeNode poll = queue.poll();
                list.add(poll.val);
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
                size--;
            }
            result.add(list);
        }
        return result;
    }
}

107.二叉树的层次遍历II

/**
 * 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<List<Integer>> levelOrderBottom(TreeNode root) {
        //层序遍历，借助队列
        List<List<Integer>> result=new ArrayList<>();
        //创造一个队列
        Queue<TreeNode> queue=new LinkedList<>();
        //树为空，直接返回
        if(root==null){
            return result;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list=new ArrayList<>();
            while(size>0){
                TreeNode poll = queue.poll();
                list.add(poll.val);
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
                size--;
            }
            result.add(list);
        }
        Collections.reverse(result);
        return result;
    }
}

199. 二叉树的右视图

/**
 * 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> rightSideView(TreeNode root) {
        List<Integer> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        //构建一个队列
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            int size=queue.size();
            while(size>0){
                TreeNode poll = queue.poll();
                size--;
                if(size==0){
                    result.add(poll.val);
                }
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
            }
        }
        return result;
    }
}

637.二叉树的层平均值

/**
 * 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<Double> averageOfLevels(TreeNode root) {
        List<Double> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            int count=size;
            double sum=0;
            while(size>0){
                size--;
                TreeNode poll = queue.poll();
                sum=sum+poll.val;
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
            }
            result.add(sum/count);
        }
        return result;
    }
}

429.N叉树的层序遍历

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

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

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

/**
 * 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) {
        List<Integer> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            int max=queue.peek().val;
            while(size>0){
                size--;
                TreeNode poll = queue.poll();
                if(poll.val>max){
                    max=poll.val;
                }
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
            }
            result.add(max);
        }
        return result;
    }
}

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

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if(root==null){
            return null;
        }
        Queue<Node> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            while(size>0){
                size--;
                Node poll = queue.poll();
                if(size==0){
                    poll.next=null;
                }else{
                    Node peek = queue.peek();
                    poll.next=peek;
                }
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
            }
        }
        return root;
    }
}

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

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if(root==null){
            return null;
        }
        Queue<Node> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            while(size>0){
                size--;
                Node poll = queue.poll();
                if(size==0){
                    poll.next=null;
                }else{
                    Node peek = queue.peek();
                    poll.next=peek;
                }
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
            }
        }
        return root;
    }
}

104.二叉树的最大深度

//迭代法，利用层序
/**
 * 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 int maxDepth(TreeNode root) {
        int result=0;
        if(root==null){
            return result;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            while(size>0){
                size--;
                TreeNode poll = queue.poll();
                if(size==0){
                    result++;
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
            }
        }
        return result;
    }
}
//递归，利用后序
/**
 * 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 int maxDepth(TreeNode root) {
        //递归，利用后序排序
        return getDepth(root);
    }
    public int getDepth(TreeNode root){
        if(root==null){
            //叶子节点
            //其实深度就是从叶子节点开始向上加的
            return 0;
        }
        int leftDepth = getDepth(root.left);
        //System.out.println(leftDepth);
        int rightDepth = getDepth(root.right);
        //System.out.println(rightDepth);
        return 1+Math.max(leftDepth,rightDepth);
    }
}

111.二叉树的最小深度

/**
 * 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 int minDepth(TreeNode root) {
        int result=0;
        if(root==null){
            return result;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        result++;
        int flag=0;
        while(!queue.isEmpty()){
            int size=queue.size();
            while(size>0){
                size--;
                TreeNode poll = queue.poll();
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
                if(poll.right==null&&poll.left==null){
                    //叶子节点
                    flag=1;
                    break;
                }
            }
            if(flag==0){
                result++;
            }else{
                break;
            }
        }
        return result;
    }
}

226.翻转二叉树

//递归法
/**
 * 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 TreeNode invertTree(TreeNode root) {
        if(root==null){
            return null;
        }
        swapNode(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
    public void swapNode(TreeNode root) {
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
    }
}
//层序遍历法
/**
 * 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 TreeNode invertTree(TreeNode root) {
        //层序遍历翻转
        if(root==null){
            return root;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            while(size>0){
                size--;
                TreeNode poll = queue.poll();
                swapChild(poll);
                if(poll.left!=null){
                    queue.offer(poll.left);
                }
                if(poll.right!=null){
                    queue.offer(poll.right);
                }
            }
        }
        return root;
    }
    public void swapChild(TreeNode node){
        TreeNode temp=node.left;
        node.left=node.right;
        node.right=temp;
    }
}

101.对称二叉树

//超级繁琐的写法，层序遍历+分别遍历左边和右边再翻转比较
/**
 * 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 boolean isSymmetric(TreeNode root) {
        if(root==null||(root.left==null&&root.right==null)){
            return true;
        }
        Queue<TreeNode> queue1=new LinkedList<>();
        Queue<TreeNode> queue2=new LinkedList<>();
        if(root.left!=null&&root.right!=null){
            queue1.offer(root.left);
            queue2.offer(root.right);
        }else{
            return false;
        }
        boolean result=true;
        while(!queue1.isEmpty()&&!queue2.isEmpty()&& result){
            List<Integer> list1=new ArrayList<>();
            List<Integer> list2=new ArrayList<>();
            int size=queue1.size();
            while(size>0){
                size--;

                TreeNode poll1 = queue1.poll();
                TreeNode poll2 = queue2.poll();

                list1.add(poll1.val);
                list2.add(poll2.val);

                if(poll1.left!=null||poll1.right!=null){
                    if(poll1.left!=null){
                        queue1.offer(poll1.left);
                    }else{
                        TreeNode leef=new TreeNode(-101);
                        queue1.offer(leef);
                    }
                    if(poll1.right!=null){
                        queue1.offer(poll1.right);
                    }else{
                        TreeNode leef=new TreeNode(-101);
                        queue1.offer(leef);
                    }
                }

                if(poll2.left!=null||poll2.right!=null){
                    if(poll2.left!=null){
                        queue2.offer(poll2.left);
                    }else{
                        TreeNode leef=new TreeNode(-101);
                        queue2.offer(leef);
                    }
                    if(poll2.right!=null){
                        queue2.offer(poll2.right);
                    }else{
                        TreeNode leef=new TreeNode(-101);
                        queue2.offer(leef);
                    }
                }
            }
            Collections.reverse(list1);
            for (int i = 0; i < list1.size(); i++) {
                if(list1.get(i) != list2.get(i)){
                    result=false;
                    break;
                }
            }
        }
        return result;
    }
}
//学习递归！
/**
 * 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 boolean isSymmetric(TreeNode root) {
        //递归法，就是要判断：
        //1.左子树的左子树和右子树的右子树
        //2.左子树的右子树和右子树的左子树
        boolean result=true;
        if(root==null||(root.left==null&&root.right==null)){
            return result;
        }
        result=compare(root.left,root.right);
        return result;
    }
    public boolean compare(TreeNode left,TreeNode right) {
        if(left==null&&right!=null){
            return false;
        }
        if(left!=null&&right==null){
            return false;
        }
        if(left==null&&right==null){
            return true;
        }
        if(left.val!= right.val){
            return false;
        }
        boolean compareOutside=compare(left.left,right.right);
        boolean compareInside=compare(left.right,right.left);
        return compareOutside&&compareInside;
    }
}
//用队列的迭代法，比自己的要简便很多
/**
 * 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 boolean isSymmetric(TreeNode root) {
        boolean result=true;
        if(root==null||(root.left==null&&root.right==null)){
            return result;
        }
        //迭代法，仍然利用队列，但是每次弹出两个，再存入1.和2.进行比较
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root.left);
        queue.offer(root.right);
        while(!queue.isEmpty()){
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();
            if(left==null&&right==null){
                continue;
            }
            if((left==null&&right!=null)||(left!=null&&right==null)||(left.val!= right.val)){
                result=false;
                break;
            }
            queue.offer(left.left);
            queue.offer(right.right);
            queue.offer(left.right);
            queue.offer(right.left);
        }
        return result;
    }
    
}

相关题目推荐

100.相同的树

/**
 * 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 boolean isSameTree(TreeNode p, TreeNode q) {
        if(p==null&&q==null){
            return true;
        }
        if((p==null&&q!=null)||(p!=null&&q==null)||(p.val!=q.val)){
            return false;
        }
        boolean result=compare(p,q);
        return result;
    }
    public boolean compare(TreeNode p, TreeNode q) {
        if(p!=null&&q==null){
            return false;
        }
        if(p==null&&q!=null){
            return false;
        }
        if(p==null&&q==null){
            return true;
        }
        if(p.val!=q.val){
            return false;
        }
        boolean compareLeft=compare(p.left,q.left);
        boolean compareRight=compare(p.right,q.right);
        return compareLeft&&compareRight;
    }
}

572.另一个树的子树

/**
 * 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 boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root==null&&subRoot!=null){
            return false;
        }
        if(root==null&&subRoot==null){
            return true;
        }
        //定义一个队列
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        boolean result=false;
        while(!queue.isEmpty()){
            if(result==true){
                break;
            }
            int size=queue.size();
            while(size>0){
                size--;
                TreeNode node = queue.poll();
                if(node.val==subRoot.val){
                    boolean compare = compare(node, subRoot);
                    if(compare){
                        result=compare;
                        break;
                    }
                }
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }
        }
        return result;
    }
    public boolean compare(TreeNode node,TreeNode subRoot){
        if(node==null&&subRoot==null){
            return true;
        }
        if(node==null&&subRoot!=null){
            return false;
        }
        if(node!=null&&subRoot==null){
            return false;
        }
        if(node.val!=subRoot.val){
            return false;
        }
        boolean compareLeft=compare(node.left,subRoot.left);
        boolean compareRight=compare(node.right,subRoot.right);
        return compareLeft&&compareRight;
    }
}
李众卿
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java-leetcode题解之第107题二叉树的层序遍历II.zip
06-18
本压缩包文件“java-leetcode题解之第107题二叉树的层序遍历II.zip”显然是针对LeetCode上的第107题的一个解决方案，该题目涉及到二叉树的层序遍历，但有一个特殊的变体。下面我们将深入探讨这个知识点。 首先，...
python-leetcode面试题解之第107题二叉树的层序遍历II.zip
04-29
本题解针对LeetCode上的第107题，即“二叉树的层序遍历II”，我们将深入探讨该问题的背景、解决方案以及它在面试中的重要意义。 二叉树是计算机科学中一种基本的数据结构，由节点组成，每个节点最多有两个子节点，...
代码随想录算法训练营第十五天| 层序遍历 226.翻转二叉树 101. 对称二叉树
qq_22081185的博客
09-07 126
层序遍历题目链接/文章讲解/视频讲解：https://programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html226.翻转二叉树 （优先掌握递归）题目链接/文章讲解/视频讲解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html。
代码随想录算法训练营第十五天| 层序遍历 226.翻转二叉树 101.对称二叉树
amytheace的博客
05-29 132
这种涉及double的题要格外小心，能在最开始declare variable的时候设成double就直接double，一个是之后运算的时候不用cast，一个是只设置为int可能会溢出。翻转正常层序遍历就行，用 reverse(levelOrder.begin(), levelOrder.end());111. 这道题和104都有两种写的方法，level traverse或者递归遍历，递归遍历以后练。116. 用现在的front() 指向pop后的front()就行。429. 见总套路，记住套路一遍过。
代码随想录算法训练营第十五天 | 层序遍历 226.翻转二叉树 101.对称二叉树
zhang1282882326的博客
03-26 606
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。，其所有叶子节点都在同一层，每个父节点都有两个子节点。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。，翻转这棵二叉树，并返回其根节点。叶子节点是指没有子节点的节点。
代码随想录算法训练营第十五天 | 层序遍历 、226.翻转二叉树、101.对称二叉树
Danny_8的博客
05-24 1295
使用队列来辅助遍历。记录每一层的个数，然后弹出一个节点，就把他的左右孩子放进队列中。当这一层的个数为0，就开始遍历下一行。 107.二叉树的层次遍历 II 199.二叉树的右视图 637.二叉树的层平均值 429.N叉树的层序遍历 515.在每个树行中找最大值 116.填充每个节点的下一个右侧节点指针 117.填充每个节点的下一个右侧节点指针II 这道题目说是二叉树，上面的116题目说是完整二叉树，116的代码有判断左右孩子是否为空，所以这道题代码和116是一样的。 111.二叉树的最小深度
代码随想录算法训练营第十八天 | 二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树
qq_52149213的博客
05-04 1024
感觉自己还是没有明白递归, 今天的算法理解的不通透, 之后还要继续看
代码随想录算法训练营第15天 | 二叉树层序遍历 226.翻转二叉树 101.对称二叉树
qq_44173169的博客
01-11 439
这样一层一层地遍历就是广度优先搜索，队列先入先出的性质是最合适的。也可以用递归的方法实现，要注意递归函数的传入参数，因为我们是一层一层遍历的，所以应该传入当前节点的所属层次。不需要返回参数，只需要保存结果数组。int。
代码随想录算法训练营第十五天 | 层序遍历 226.翻转二叉树 101.对称二叉树 2
a20010616的博客
08-23 110
这道题目 一些做过的同学 理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。看完本篇可以一口气刷十道题，试一试， 层序遍历并不难，大家可以很快刷了十道题。101. 对称二叉树 （优先掌握递归）226.翻转二叉树 （优先掌握递归）先看视频讲解，会更容易一些。
代码随想录算法训练营第15天|层序遍历 226.翻转二叉树 101.对称二叉树 2
weixin_43646251的博客
02-08 197
【代码】代码随想录算法训练营第15天|层序遍历 226.翻转二叉树 101.对称二叉树 2。
代码随想录算法训练营第十五天 | 层序遍历、226.翻转二叉树、101.对称二叉树
owlmo的博客
12-27 1141
然后将当前节点的left指向当前的右子树，right指向当前的左子树，做翻转操作。否则进行递归处理，判断当前对应的两棵子树是否对称，判断的根据还是根据两棵子树是否为空、两棵子树的对称位置子树是否一致等。思路：进行层次遍历，如果在遍历时，发现当前有一个节点既没有左子树又没有右子树，则当前节点的深度为二叉树的最小深度。思路：进行层次遍历，然后对每层的结果做平均，注意每个节点的数值是否越过int的边界。思路：进行层序遍历，然后在遍历的过程中不断地将每层的前一个节点指向后一个节点。给你一个二叉树的根节点。
8606-二叉树的构建及遍历操作.rar_二叉树_遍历算法
09-21
用户可以通过阅读代码了解二叉树的构建方法和遍历算法的具体实现细节，也可以直接运行代码进行测试，加深对二叉树的理解。同时，这是一个很好的实践项目，可以帮助初学者巩固数据结构基础，提高编程技能。 总结来说...
二叉树的层序遍历 II.md
11-17
二叉树的层序遍历 II.md
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
算法-KMP字符串匹配
xx_xb的博客
07-23 176
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 659
AtCoder Beginner Contest 363 ABCDE
【LeetCode】141.环形链表、142. 环形链表 II（算法 + 图解）
最新发布
明志の博客
07-25 618
环形链表
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 754
二叉搜索树向左或向右指明方向，不用遍历整个树。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值