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

最新推荐文章于 2024-07-24 20:44:05 发布
最新推荐文章于 2024-07-24 20:44:05 发布
阅读量650 收藏 18
点赞数 5
分类专栏： LeetCode 算法学习 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreamtang/article/details/139126519
版权

0102.二叉树的层序遍历 文章解释

自己看到题目的第一想法

    当我们拿到一个数的头节点开始遍历的时候, 我们在单次循环中可以拿到三个节点: 头节点、头节点的左节点、头节点的右节点. 这时候是可以得到层序遍历的结果的. 但是当深度到达第三层的时候, 左侧的节点, 就无法链接到右侧的节点. 这可怎么办呢? 拿一个独立的节点去记录分叉的位置吗? 如果深度继续往下, 分叉点变得越来越多. 有办法通过迭代的方式记录这些分叉点吗?

   头好大T_T 还是先看视频吧.

看完代码随想录之后的想法

   原来只要拿一个队列保存住当前深度的所有节点, 遍历完成后生成下一层的节点列表就可以. 还是挺简单的.

102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000
/**
 * 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<>();
        if (root == null) {
            return result;
        }
        LinkedList<TreeNode> nodes = new LinkedList<>();
        List<Integer> sameDepthNodeValues = null;
        TreeNode node = null;
        int size = 0;;

        nodes.addLast(root);
        while (!nodes.isEmpty()) {
            size = nodes.size();
            sameDepthNodeValues = new ArrayList<>();
            while (size-- > 0) {
                node = nodes.pop();
                if (node.left != null) {
                    nodes.addLast(node.left);
                }
                if (node.right != null) {
                    nodes.addLast(node.right);
                }
                sameDepthNodeValues.add(node.val);
            }
            result.add(sameDepthNodeValues);
        }
        return result;
    }
}

107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000
/**
 * 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<>();
        if (root == null) {
            return result;
        }

        LinkedList<TreeNode> nodes = new LinkedList<>();
        List<Integer> sameDephNodeValues = null;
        TreeNode node = null;
        int size;


        nodes.addLast(root);
        while (!nodes.isEmpty()) {
            size = nodes.size();
            sameDephNodeValues = new ArrayList<>();
            while (size-- > 0) {
                node = nodes.pop();
                if (node.left != null) {
                    nodes.addLast(node.left);
                }
                if (node.right != null) {
                    nodes.addLast(node.right);
                }
                sameDephNodeValues.add(node.val);
            }
            result.add(sameDephNodeValues);
        }

        for (int i = 0; i < result.size()/2; i++) {
            sameDephNodeValues = result.get(i);
            result.set(i, result.get(result.size() - 1 - i));
            result.set(result.size() - 1 - i, sameDephNodeValues);
        }
        return result;
    }
}

 199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

/**
 * 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;
 *     }
 * }
 */
// 不是很高效的解法: 评分排名才 80%
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        LinkedList<TreeNode> nodes = new LinkedList<>();
        TreeNode node;
        int size;
        
        nodes.addLast(root);
        while (!nodes.isEmpty()) {
            size = nodes.size();
            while (size-- > 0){
                node = nodes.pop();
                if (size == 0) {
                    result.add(node.val);
                }
                if (node.left != null) {
                    nodes.addLast(node.left);
                }
                if (node.right != null) {
                    nodes.addLast(node.right);
                }
            }
        }
        return result;
    }
}

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

提示：

  • 树中节点数量在 [1, 10^4] 范围内
  • -2^31 <= Node.val <= 2^31 - 1
/**
 * 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;
        }
        double sum;
        LinkedList<TreeNode> nodes = new LinkedList<>();
        TreeNode node;
        int size;
        int nodeSize;
        nodes.addLast(root);
        while (!nodes.isEmpty()) {
            size = nodeSize = nodes.size();
            sum = 0;
            while (size-- > 0) {
                node = nodes.pop();
                sum += node.val;
                if (node.left != null) {
                    nodes.add(node.left);
                }
                if (node.right != null) {
                    nodes.add(node.right);
                }
            }
            result.add(sum/nodeSize);
        }
        return result;
    }
}
// 递归法: 并没有更快
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Map<Integer, Double> numberSum = new HashMap<>();
        Map<Integer, Integer> numberCount = new HashMap<>();
        averageOfLevelsRecursion(root, numberSum, numberCount, 0);
        for (int i = 0; i < numberSum.size(); i++) {
            result.add(numberSum.get(i)/numberCount.get(i));
        }
        return result;
    }

    private void averageOfLevelsRecursion(TreeNode node, Map<Integer, Double> sums, Map<Integer, Integer> counts, int depth) {
        double sum = sums.getOrDefault(depth, 0.0);
        sum += node.val;
        sums.put(depth, sum);
        counts.put(depth, counts.getOrDefault(depth, 0) + 1);
        
        if (node.left != null) {
            averageOfLevelsRecursion(node.left, sums, counts, depth + 1);
        }
        if (node.right != null) {
            averageOfLevelsRecursion(node.right, sums, counts, depth + 1);
        }
    }
}

429. N 叉树的层序遍历

// 二叉树的层序遍历复制过来改一两句代码就行了, 效率尚可. 92%
/*
// 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;
        }
        LinkedList<Node> nodes = new LinkedList<>();
        List<Integer> sameDepthNodeValues = null;
        Node node = null;
        int size = 0;;

        nodes.addLast(root);
        while (!nodes.isEmpty()) {
            size = nodes.size();
            sameDepthNodeValues = new ArrayList<>();
            while (size-- > 0) {
                node = nodes.pop();
                if (node.children != null) {
                    nodes.addAll(node.children);
                }
                sameDepthNodeValues.add(node.val);
            }
            result.add(sameDepthNodeValues);
        }
        return result;
    }
}

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

// 因为没有排序, 所以需要遍历所有的元素. 效率一般: 90%
/**
 * 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;
        }
        ArrayDeque<TreeNode> nodes = new ArrayDeque<>();
        TreeNode node = null;
        int size;
        Integer maxNumber;
        nodes.addLast(root);
        while (!nodes.isEmpty()) {
            size = nodes.size();
            maxNumber = null;
            while (size-- > 0) {
                node = nodes.pop();
                if (maxNumber == null) {
                    maxNumber = node.val;
                } else if (node.val > maxNumber) {
                    maxNumber = node.val;
                }
                if (node.left != null) {
                    nodes.addLast(node.left);
                }
                if (node.right != null) {
                    nodes.addLast(node.right);
                }
            }
            result.add(maxNumber);
        }
        return result;
    }
}

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

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;
    }
};
*/
// 效率很差: 83.7%
class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return null;
        }
        ArrayDeque<Node> nodes = new ArrayDeque<>();
        Node node = null;
        Node lastNode = null;
        nodes.addLast(root);
        while (!nodes.isEmpty()) {
            int size = nodes.size();
            lastNode = null;
            while (size-- > 0) {
                node = nodes.pop();
                if (node.left != null) {
                    nodes.addLast(node.left);
                }
                if (node.right != null) {
                    nodes.addLast(node.right);
                }
                if (lastNode == null) {
                    lastNode = node;
                } else {
                    lastNode.next = node;
                    lastNode = lastNode.next;
                }
            }
        }
        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) {
        LinkedList<TreeNode> nodes = new LinkedList<>();
        if (root == null) {
            return 0;
        }
        nodes.addLast(root);
        TreeNode node = null;
        int depth = 0;
        while (!nodes.isEmpty()) {
            int size = nodes.size();
            depth++;
            while(size-- > 0) {
                node = nodes.pop();
                if (node.left != null) {
                    nodes.addLast(node.left);
                }
                if (node.right != null) {
                    nodes.addLast(node.right);
                }
            }
        }
        return depth;
    }
}
/**
 * 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) {
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 1;
        }
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

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;
 *     }
 * }
 */
// 这里用迭代法效率很高: 99.99%
class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        LinkedList<TreeNode> nodes = new LinkedList<>();
        nodes.addLast(root);
        TreeNode node = null;
        int depth = 0;
        while (!nodes.isEmpty()) {
            int size = nodes.size();
            depth++;
            while (size-- > 0) {
                node = nodes.pop();
                if (node.left == null && node.right == null) {
                    return depth;
                }
                if (node.left != null) {
                    nodes.addLast(node.left);
                }
                if (node.right != null) {
                    nodes.addLast(node.right);
                }
            }
        }
        return depth;
    }
}
/**
 * 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;
 *     }
 * }
 */
// 递归法: 效率极低 60%
class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        int leftNodeDepth = minDepth(root.left);
        int rightNodeDepth = minDepth(root.right);
        
        if (leftNodeDepth > 0 && rightNodeDepth == 0) {
            return leftNodeDepth + 1;
        } else if (leftNodeDepth == 0 && rightNodeDepth > 0) {
            return rightNodeDepth + 1;
        } else {
            return Math.min(leftNodeDepth, rightNodeDepth) + 1;
        }
    }
}

[LeetCode] 226. 翻转二叉树

[LeetCode] 226. 翻转二叉树 文章解释

[LeetCode] 226. 翻转二叉树 视频解释

给你一棵二叉树的根节点 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 Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        TreeNode node = root.left;
        root.left = root.right;
        root.right = node;
        invertTree(root.left);
        invertTree(root.right);
        return 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 Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        invertTree(root.left);
        invertTree(root.right);
        TreeNode node = root.left;
        root.left = root.right;
        root.right = node;
        return 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 Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        invertTree(root.right);// root.left
        TreeNode node = root.left;
        root.left = root.right;
        root.right = node;
        invertTree(root.right);// root.left
        return root;
    }
}
// 迭代法: 效率极高 100%
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        LinkedList<TreeNode> nodes = new LinkedList<>();
        TreeNode node;
        TreeNode temp;
        nodes.addLast(root);

        while (!nodes.isEmpty()) {
            int size = nodes.size();
            while (size-- > 0) {
                node = nodes.pop();
                temp = node.left;
                node.left = node.right;
                node.right = temp;
                if (node.left != null) {
                    nodes.addLast(node.left);
                }
                if (node.right != null) {
                    nodes.addLast(node.right);
                }
            }
        }
        return root;
    }
}
// 迭代法
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        LinkedList<TreeNode> nodes = new LinkedList<>();
        TreeNode node = root;
        TreeNode temp = null;

        while (node != null || !nodes.isEmpty()) {
            if (node != null) {
                nodes.push(node);
                node = node.left;
            } else {
                node = nodes.pop();
                temp = node.left;
                node.left = node.right;
                node.right = temp;
                node = node.left;
            }
        }
        return root;
    }
}
// 统一风格迭代法
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        LinkedList<TreeNode> nodes = new LinkedList<>();
        nodes.push(root);
        TreeNode node;
        TreeNode temp;
        while (!nodes.isEmpty()) {
            node = nodes.pop();
            if (node != null) {
                if (node.right != null) {
                    nodes.push(node.right);
                }
                if (node.left != null) {
                    nodes.push(node.left);
                }
                nodes.push(node);
                nodes.push(null);
            } else {
                node = nodes.pop();
                temp = node.left;
                node.left = node.right;
                node.right = temp;
            }
        }
        return root;
    }
}

[LeetCode] 101. 对称二叉树

[LeetCode] 101. 对称二叉树 文章解释

[LeetCode] 101. 对称二叉树 视频解释

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

提示：

  • 树中节点数目在范围 [1, 1000] 内
  • -100 <= Node.val <= 100
// 递归法
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return isSymmetric(root.left, root.right);
    }

    private boolean isSymmetric(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        } else if (left == null && right != null) {
            return false;
        } else if (right == null) {
            return false;
        } else if (left.val != right.val) {
            return false;
        }
        return isSymmetric(left.left, right.right)
                && isSymmetric(left.right, right.left);
    }
}
// 迭代法: 效率一般 17.7%...
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        Stack<TreeNode> nodes = new Stack<>();
        nodes.push(root.right);
        nodes.push(root.left);
        TreeNode left;
        TreeNode right;
        while (!nodes.isEmpty()) {
            left = nodes.pop();
            right = nodes.pop();
            if (left == null && right == null) {
               continue;
            } else if (left == null && right != null) {
                return false;
            } else if (right == null) {
                return false;
            } else if (left.val != right.val) {
                return false;
            }
            nodes.push(left.left);
            nodes.push(right.right);
            nodes.push(left.right);
            nodes.push(right.left);
        }
        return true;
    }   
}

dreamtang
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java-leetcode题解之第107题二叉树的层序遍历II.zip
06-18
本压缩包文件“java-leetcode题解之第107题二叉树的层序遍历II.zip”显然是针对LeetCode上的第107题的一个解决方案，该题目涉及到二叉树的层序遍历，但有一个特殊的变体。下面我们将深入探讨这个知识点。 首先，...
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历.txt
05-20
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历
代码随想录算法训练营第15天 | 二叉树层序遍历 226.翻转二叉树 101.对称二叉树
qq_44173169的博客
01-11 440
这样一层一层地遍历就是广度优先搜索，队列先入先出的性质是最合适的。也可以用递归的方法实现，要注意递归函数的传入参数，因为我们是一层一层遍历的，所以应该传入当前节点的所属层次。不需要返回参数，只需要保存结果数组。int。
代码随想录算法训练营第十五天| 二叉树层序遍历 226.翻转二叉树 101. 对称二叉树
L1692579428的博客
12-13 77
二叉树层序遍历 226.翻转二叉树 101. 对称二叉树
代码随想录算法训练营第十五天 | 层序遍历 、226.翻转二叉树、101.对称二叉树
Danny_8的博客
05-24 1295
使用队列来辅助遍历。记录每一层的个数，然后弹出一个节点，就把他的左右孩子放进队列中。当这一层的个数为0，就开始遍历下一行。 107.二叉树的层次遍历 II 199.二叉树的右视图 637.二叉树的层平均值 429.N叉树的层序遍历 515.在每个树行中找最大值 116.填充每个节点的下一个右侧节点指针 117.填充每个节点的下一个右侧节点指针II 这道题目说是二叉树，上面的116题目说是完整二叉树，116的代码有判断左右孩子是否为空，所以这道题代码和116是一样的。 111.二叉树的最小深度
代码随想录算法训练营第15天| 二叉树层序遍历、226.翻转二叉树、 101. 对称二叉树*
kline189的博客
03-20 636
/ 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的。que.empty()) { // 修改了这里的语法错误，添加了缺失的闭合括号。
代码随想录算法训练营第十八天 | 二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树
qq_52149213的博客
05-04 1025
感觉自己还是没有明白递归, 今天的算法理解的不通透, 之后还要继续看
代码随想录算法训练营第十五天 | 层序遍历、226.翻转二叉树、101.对称二叉树
owlmo的博客
12-27 1141
然后将当前节点的left指向当前的右子树，right指向当前的左子树，做翻转操作。否则进行递归处理，判断当前对应的两棵子树是否对称，判断的根据还是根据两棵子树是否为空、两棵子树的对称位置子树是否一致等。思路：进行层次遍历，如果在遍历时，发现当前有一个节点既没有左子树又没有右子树，则当前节点的深度为二叉树的最小深度。思路：进行层次遍历，然后对每层的结果做平均，注意每个节点的数值是否越过int的边界。思路：进行层序遍历，然后在遍历的过程中不断地将每层的前一个节点指向后一个节点。给你一个二叉树的根节点。
代码随想录算法训练营第十五天| 层序遍历 ，226.翻转二叉树 ，101.对称二叉树
m0_43385261的博客
03-06 177
今日任务层序遍历 ，226.翻转二叉树 ，101.对称二叉树。
代码随想录算法训练营第十五天 | 层序遍历，226.翻转二叉树 ，101. 对称二叉树
Y_Zoom的博客
06-05 487
在写层序遍历Ⅱ的时候一直报no member named 'levelOrderBottom'，检查好几遍才发现原有的函数名被我不小心改了，所以报错，也没有给我指出哪一行有问题，憋了好一会。几个月前做过，现在做还是有点陌生，处理对称的逻辑一定要学会。层序和递归都可以做，递归先swap后swap都一样。104和111可以用递归，就是不太容易理解。116题感觉力扣官方题解更简便一点。
代码随想录算法训练营第十八天| 二叉树层序遍历、226.翻转二叉树、 101.对称二叉树
m0_57160016的博客
05-04 348
代码随想录Day18
代码随想录算法训练营第十五天|层序遍历、226.翻转二叉树、101.对称二叉树
m0_71413464的博客
12-27 396
详解：队列先进先出，符合层序遍历的广度优先遍历；栈先进后出使用于模拟深度优先遍历的递归遍历逻辑。递归法：利用depth记录当前递归所在的层数，多少层数的递归，就放在第几行的vector中。解法1：收集孩子的信息，向上进行反馈，用后序。
8606-二叉树的构建及遍历操作.rar_二叉树_遍历算法
09-21
用户可以通过阅读代码了解二叉树的构建方法和遍历算法的具体实现细节，也可以直接运行代码进行测试，加深对二叉树的理解。同时，这是一个很好的实践项目，可以帮助初学者巩固数据结构基础，提高编程技能。 总结来说...
102二叉树的层序遍历.js
09-22
前端算法 二叉树的层序遍历通过DFS或BFS遍历，依次遍历二叉树遍历的结果值。队列满足先进先出的要求,出列就，新的层进来，旧的层出来
二叉树层序遍历.zip
02-07
在这个“二叉树层序遍历.zip”资源中，我们可以期待深入学习二叉树的层序遍历算法以及其实现方法。 首先，我们要理解什么是二叉树。二叉树是每个节点最多有两个子节点的数据结构，通常分为左子节点和右子节点。...
算法-KMP字符串匹配
xx_xb的博客
07-23 191
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 679
AtCoder Beginner Contest 363 ABCDE
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 244
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 832
二叉搜索树向左或向右指明方向，不用遍历整个树。
代码随想录刷题训练营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、付费专栏及课程。

余额充值