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

最新推荐文章于 2024-07-19 19:11:19 发布
最新推荐文章于 2024-07-19 19:11:19 发布
阅读量649 收藏 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 437
这样一层一层地遍历就是广度优先搜索，队列先入先出的性质是最合适的。也可以用递归的方法实现，要注意递归函数的传入参数，因为我们是一层一层遍历的，所以应该传入当前节点的所属层次。不需要返回参数，只需要保存结果数组。int。
代码随想录算法训练营第十五天| 二叉树层序遍历 226.翻转二叉树 101. 对称二叉树
L1692579428的博客
12-13 75
二叉树层序遍历 226.翻转二叉树 101. 对称二叉树
代码随想录算法训练营第十五天 | 层序遍历 、226.翻转二叉树、101.对称二叉树
Danny_8的博客
05-24 1291
使用队列来辅助遍历。记录每一层的个数，然后弹出一个节点，就把他的左右孩子放进队列中。当这一层的个数为0，就开始遍历下一行。 107.二叉树的层次遍历 II 199.二叉树的右视图 637.二叉树的层平均值 429.N叉树的层序遍历 515.在每个树行中找最大值 116.填充每个节点的下一个右侧节点指针 117.填充每个节点的下一个右侧节点指针II 这道题目说是二叉树，上面的116题目说是完整二叉树，116的代码有判断左右孩子是否为空，所以这道题代码和116是一样的。 111.二叉树的最小深度
代码随想录算法训练营第15天| 二叉树层序遍历、226.翻转二叉树、 101. 对称二叉树*
kline189的博客
03-20 632
/ 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的。que.empty()) { // 修改了这里的语法错误，添加了缺失的闭合括号。
代码随想录算法训练营第十八天 | 二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树
qq_52149213的博客
05-04 1020
感觉自己还是没有明白递归, 今天的算法理解的不通透, 之后还要继续看
8606-二叉树的构建及遍历操作.rar_二叉树_遍历算法
09-21
用户可以通过阅读代码了解二叉树的构建方法和遍历算法的具体实现细节，也可以直接运行代码进行测试，加深对二叉树的理解。同时，这是一个很好的实践项目，可以帮助初学者巩固数据结构基础，提高编程技能。 总结来说...
102二叉树的层序遍历.js
09-22
前端算法 二叉树的层序遍历通过DFS或BFS遍历，依次遍历二叉树遍历的结果值。队列满足先进先出的要求,出列就，新的层进来，旧的层出来
二叉树层序遍历.zip
02-07
在这个“二叉树层序遍历.zip”资源中，我们可以期待深入学习二叉树的层序遍历算法以及其实现方法。 首先，我们要理解什么是二叉树。二叉树是每个节点最多有两个子节点的数据结构，通常分为左子节点和右子节点。...
【18】输出字符菱形
2301_78786609的博客
07-19 287
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 108
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 185
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
常见的排序算法，复杂度
m0_61544805的博客
07-16 516
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
代码随想录学习 54day 图论 A star算法
qq_40445763的博客
07-17 370
【代码】代码随想录学习 54day 图论 A star算法。
树与二叉树
2201_76027754的博客
07-15 797
树和二叉树
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 193
完全二叉树的节点个数-递归
【java】力扣 H指数
qq_55846232的博客
07-17 275
java 力扣 H指数
【算法】算法模板
qq_44765647的博客
07-19 176
LeetCode网站中学习算法的过程中使用到并总结的算法模板算法模板 数组算法模板，字符串算法模板，列表算法模板，数学算法模板，树算法模板，图算法模板，动态规划算法模板
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值