Leetcode高频算法题：二叉树篇（二）

已于 2023-08-01 16:21:46 修改
阅读量91 收藏 1
点赞数 3
分类专栏： 数据结构与算法 文章标签： 算法 leetcode java
于 2023-07-28 18:40:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22270363/article/details/131985295
版权

目录

1. 二叉树的层序遍历：给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：
二叉树：[3,9,20,null,null,15,7]
在这里插入图片描述
返回其层序遍历结果：
[
[3],
[9,20],
[15,7]
]

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> list = new ArrayList<>();
    if (root == null) {
        return list;
    }
    Deque<TreeNode> deque = new LinkedList<>();
    deque.offerLast(root);
    while (!deque.isEmpty()) {
        List<Integer> temp = new ArrayList<>();
        Integer size = deque.size();
        for (int i = 0; i < size; i++) {
            TreeNode node = deque.pollFirst();
            temp.add(node.val);
            if(node.left != null){
                deque.offerLast(node.left);
            }
            if(node.right != null){
                deque.offerLast(node.right);
            }
        }
        list.add(temp);
    }
    return list;
}

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

示例：
在这里插入图片描述
输入： [1,2,3,null,5,null,4]
输出：[1,3,4]

public List<Integer> rightSideView1(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    if (root == null) {
        return result;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        int curSize = queue.size();
        for (int i = 1; i <= curSize; i++) {
            TreeNode node = queue.poll();
            if (i == curSize) {
                result.add(node.val);
            }
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }
    return result;
}

3. 重建二叉树：输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

示例：
在这里插入图片描述
Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

private Map<Integer, Integer> indexMap;

public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
    if (preorder_left > preorder_right) {
        return null;
    }

    // 前序遍历中的第一个节点就是根节点
    int preorder_root = preorder_left;
    // 在中序遍历中定位根节点
    int inorder_root = indexMap.get(preorder[preorder_root]);

    // 先把根节点建立出来
    TreeNode root = new TreeNode(preorder[preorder_root]);
    // 得到左子树中的节点数目
    int size_left_subtree = inorder_root - inorder_left;
    // 递归地构造左子树，并连接到根节点
    // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
    root.left = myBuildTree(preorder, inorder, preorder_left + 1,
            preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
    // 递归地构造右子树，并连接到根节点
    // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
    root.right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1,
            preorder_right, inorder_root + 1, inorder_right);
    return root;
}

public TreeNode buildTree(int[] preorder, int[] inorder) {
    int n = preorder.length;
    // 构造哈希映射，帮助我们快速定位根节点
    indexMap = new HashMap<Integer, Integer>();
    for (int i = 0; i < n; i++) {
        indexMap.put(inorder[i], i);
    }
    return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
}

4. 不同的二叉搜索树II：给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树 。可以按 任意顺序 返回答案。

示例：
在这里插入图片描述
输入：n = 3
输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]

public List<TreeNode> generateTrees(int n) {
    if (n == 0) {
        return new LinkedList<TreeNode>();
    }
    return generateTrees(1, n);
}
public List<TreeNode> generateTrees(int start, int end) {
    List<TreeNode> allTrees = new LinkedList<TreeNode>();
    if (start > end) {
        allTrees.add(null);
        return allTrees;
    }
    // 枚举可行根节点
    for (int i = start; i <= end; i++) {
        // 获得所有可行的左子树集合
        List<TreeNode> leftTrees = generateTrees(start, i - 1);
        // 获得所有可行的右子树集合
        List<TreeNode> rightTrees = generateTrees(i + 1, end);
        // 从左子树集合中选出一棵左子树，从右子树集合中选出一棵右子树，拼接到根节点上
        for (TreeNode left : leftTrees) {
            for (TreeNode right : rightTrees) {
                TreeNode currTree = new TreeNode(i);
                currTree.left = left;
                currTree.right = right;
                allTrees.add(currTree);
            }
        }
    }
    return allTrees;
}

5. 二叉树中和为某一值的路径：给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。叶子节点 是指没有子节点的节点。

示例：
在这里插入图片描述
输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

List<List<Integer>> result = new LinkedList<>();
Deque<Integer> path = new LinkedList<>();
public List<List<Integer>> pathSum(TreeNode root, int target) {
    dealList(root, target);
    return result;
}
private void dealList(TreeNode root, int target) {
    if (root == null) {
        return;
    }
    target = target - root.val;
    path.offerLast(root.val);
    if (root.left == null && root.right == null && target == 0) {
        result.add(new LinkedList<>(path));
    }
    dealList(root.left, target);
    dealList(root.right, target);
    path.pollLast();
}

6. 二叉两个链表的第一个公共节点：输入两个链表，找出它们的第一个公共节点。如下面的两个链表：

示例：
在这里插入图片描述
输入：listA = [0,9,1,2,4], listB = [3,2,4]
输出：Reference of the node with value = 2

ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    ListNode first = headA;
    ListNode second = headB;
    while(first != second){
        if(first != null){
            first = first.next;
        }else{
            first = headB;
        }
        if(second != null){
            second = second.next;
        }else{
            second = headA;
        }
    }
    return first;
}

7. 二叉树中所有距离为 K 的结点：给定一个二叉树（具有根结点 root）， 一个目标结点 target ，和一个整数值 K 。返回到目标结点 target 距离为 K 的所有结点的值的列表。 答案可以以任何顺序返回。

示例：
在这里插入图片描述
输入：root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, k = 2
输出：[7,4,1]
解释：所求结点为与目标结点（值为 5）距离为 2 的结点，值分别为 7，4，以及 1

Map<Integer, TreeNode> parents = new HashMap<Integer, TreeNode>();
List<Integer> ans = new ArrayList<Integer>();

public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
    // 从 root 出发 DFS，记录每个结点的父结点
    findParents(root);

    // 从 target 出发 DFS，寻找所有深度为 k 的结点
    findAns(target, null, 0, k);

    return ans;
}

public void findParents(TreeNode node) {
    if (node.left != null) {
        parents.put(node.left.val, node);
        findParents(node.left);
    }
    if (node.right != null) {
        parents.put(node.right.val, node);
        findParents(node.right);
    }
}

public void findAns(TreeNode node, TreeNode from, int depth, int k) {
    if (node == null) {
        return;
    }
    if (depth == k) {
        ans.add(node.val);
        return;
    }
    if (node.left != from) {
        findAns(node.left, node, depth + 1, k);
    }
    if (node.right != from) {
        findAns(node.right, node, depth + 1, k);
    }
    if (parents.get(node.val) != from) {
        findAns(parents.get(node.val), node, depth + 1, k);
    }
}

8. 填充每个节点的下一个右侧节点指针：给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

示例：
在这里插入图片描述
输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]

方法一：采用层序遍历的方式

public Node connect(Node root) {
    if (root == null) {
        return root;
    }

    // 初始化队列同时将第一层节点加入队列中，即根节点
    Queue<Node> queue = new LinkedList<Node>();
    queue.add(root);

    // 外层的 while 循环迭代的是层数
    while (!queue.isEmpty()) {

        // 记录当前队列大小
        int size = queue.size();

        // 遍历这一层的所有节点
        for (int i = 0; i < size; i++) {

            // 从队首取出元素
            Node node = queue.poll();

            // 连接
            if (i < size - 1) {
                node.next = queue.peek();
            }

            // 拓展下一层节点
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
    }
    // 返回根节点
    return root;
}

方法二：使用已建立的next 指针

public Node connect(Node root) {
    if(root == null){
        return null;
    }
    dealNode(root);
    return root;
}
private void dealNode(Node root) {
    if(root.left == null){
        return;
    }
    Node cur = root;
    while(cur != null){
        cur.left.next = cur.right;
        if(cur.next != null){
            cur.right.next = cur.next.left;
        }
        cur = cur.next;
    }
    dealNode(root.left);
}

9. 二叉搜索树的最近公共祖先：给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例：
在这里插入图片描述
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6

方法一：时间空间复杂度均为O(N)的写法

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if (root == null) {
        return null;
    }
    if (root == p || root == q) {
        return root;
    }
    TreeNode left = lowestCommonAncestor(root.left, p, q);
    TreeNode right = lowestCommonAncestor(root.right, p, q);
    if (left != null && right != null) {
        return root;
    }
    if (left != null) {
        return left;
    }
    if (right != null) {
        return right;
    }
    return null;
}

方法二：时间复杂度为O(N)，空间复杂度为O(1)的写法

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while(root != null){
            if(root.val < p.val && root.val < q.val){
                root = root.right;
            }else if(root.val > p.val && root.val > q.val){
                root = root.left;
            }else{
                break;
            }
        }
        return root;
}

10. 将有序数组转换为二叉搜索树:给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例：
在这里插入图片描述
输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案

static int[] arr;
public static TreeNode sortedArrayToBST(int[] nums) {
    arr = nums;
    return buildTree(0, nums.length - 1);
}
private static TreeNode buildTree(int left, int right) {
    if (left > right) {
        return null;
    }
    int mid = (left + right) / 2;
    TreeNode treeNode = new TreeNode();
    treeNode.left = buildTree(left, mid - 1);
    treeNode.val = arr[mid];
    treeNode.right = buildTree(mid + 1, right);
    return treeNode;
}

11. 相同的树：给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例：
在这里插入图片描述
输入：p = [1,2,3], q = [1,2,3]
输出：true

public boolean isSameTree(TreeNode p, TreeNode q) {
    if (p == null && q == null) {
        return true;
    }
    else if (p == null || q == null) {
        return false;
    }
    else if (p.val != q.val) {
        return false;
    }
    return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}

12. 二叉树中第二小的节点：给定一个非空特殊的二叉树，每个节点都是正数，并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话，那么该节点的值等于两个子节点中较小的一个。更正式地说，root.val = min(root.left.val, root.right.val) 总成立。给出这样的一个二叉树，你需要输出所有节点中的第二小的值。如果第二小的值不存在的话，输出 -1 。

在这里插入图片描述
输入：root = [2,2,5,null,null,5,7]
输出：5
解释：最小的值是 2 ，第二小的值是 5 。

int ans;
int rootvalue;
public int findSecondMinimumValue(TreeNode root) {
    ans = -1;
    rootvalue = root.val;
    dfs(root);
    return ans;
}

public void dfs(TreeNode node) {
    if (node == null) {
        return;
    }
    if (ans != -1 && node.val >= ans) {
        return;
    }
    if (node.val > rootvalue) {
        ans = node.val;
    }
    dfs(node.left);
    dfs(node.right);
}

补充说明：
在这里插入图片描述

13. 最大二叉树：给定一个不含重复元素的整数数组 nums 。一个以此数组直接递归构建的 最大二叉树 定义如下：

1.二叉树的根是数组 nums 中的最大元素。
2.左子树是通过数组中 最大值左边部分 递归构造出的最大二叉树。
3.右子树是通过数组中 最大值右边部分 递归构造出的最大二叉树。
返回有给定数组 nums 构建的 最大二叉树 。

示例：
在这里插入图片描述
输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]

static int[] arrays;
public static TreeNode constructMaximumBinaryTree(int[] nums) {
    arrays = nums;
    return buildTree(0, nums.length - 1);
}
private static TreeNode buildTree(int left, int right) {
    if (left > right) {
        return null;
    }
    int index = left;
    for (int i = left; i <= right; i++) {
        if (arrays[i] > arrays[index]) {
            index = i;
        }
    }
    TreeNode treeNode = new TreeNode();
    treeNode.val = arrays[index];
    treeNode.left = buildTree(left, index - 1);
    treeNode.right = buildTree(index + 1, right);
    return treeNode;
}

14. 二叉树的镜像：请完成一个函数，输入一个二叉树，该函数输出它的镜像。

输入：
在这里插入图片描述
输出：
在这里插入图片描述
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

public TreeNode mirrorTree(TreeNode root) {
    if(root == null){
        return null;
    }
    TreeNode left = mirrorTree(root.right);
    TreeNode right = mirrorTree(root.left);
    root.left = left;
    root.right = right;
    return root;
}

15. 二叉树的坡度：给你一个二叉树的根节点 root ，计算并返回 整个树 的坡度 。一个树的 节点的坡度 定义即为，该节点左子树的节点之和和右子树节点之和的 差的绝对值 。如果没有左子树的话，左子树的节点之和为 0 ；没有右子树的话也是一样。空结点的坡度是 0 。整个树 的坡度就是其所有节点的坡度之和。

示例：
在这里插入图片描述
输入：root = [1,2,3]
输出：1
解释：
节点 2 的坡度：|0-0| = 0（没有子节点）
节点 3 的坡度：|0-0| = 0（没有子节点）
节点 1 的坡度：|2-3| = 1（左子树就是左子节点，所以和是 2 ；右子树就是右子节点，所以和是 3 ）
坡度总和：0 + 0 + 1 = 1

int slope = 0;
public int findTilt(TreeNode root) {
    dfs(root);
    return slope;
}
private int dfs(TreeNode root) {
    if(root == null){
        return 0;
    }
    int left = dfs(root.left);
    int right = dfs(root.right);
    slope = slope + Math.abs(left - right);
    return root.val + left + right;
}

16. 二叉树的锯齿形层序遍历：给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

示例：
在这里插入图片描述
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> list = new LinkedList<>();
    if (root == null) {
        return list;
    }
    Deque<TreeNode> deque = new LinkedList<>();
    deque.offerLast(root);
    boolean isOrderLeft = true;
    while (!deque.isEmpty()) {
        Deque<Integer> temp = new LinkedList<>();
        Integer size = deque.size();
        for (int i = 0; i < size; i++) {
            TreeNode node = deque.pollFirst();
            if(isOrderLeft){
                temp.offerLast(node.val);
            }else{
                temp.offerFirst(node.val);
            }
            if(node.left != null){
                deque.offerLast(node.left);
            }
            if(node.right != null){
                deque.offerLast(node.right);
            }
        }
        isOrderLeft = !isOrderLeft;
        list.add(new LinkedList<>(temp));
    }
    return list;
}

17. 求根节点到叶节点数字之和：给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。每条从根节点到叶节点的路径都代表一个数字：例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。计算从根节点到叶节点生成的 所有数字之和 。叶节点 是指没有子节点的节点。

示例；
在这里插入图片描述
输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

方法一

public int sumNumbers(TreeNode root) {
    return dfs(root, 0);
}

public int dfs(TreeNode root, int prevSum) {
    if (root == null) {
        return 0;
    }
    int sum = prevSum * 10 + root.val;
    if (root.left == null && root.right == null) {
        return sum;
    } else {
        return dfs(root.left, sum) + dfs(root.right, sum);
    }
}

方法二

public int sumNumbers1(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int sum = 0;
    Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
    Queue<Integer> numQueue = new LinkedList<Integer>();
    nodeQueue.offer(root);
    numQueue.offer(root.val);
    while (!nodeQueue.isEmpty()) {
        TreeNode node = nodeQueue.poll();
        int num = numQueue.poll();
        TreeNode left = node.left, right = node.right;
        if (left == null && right == null) {
            sum += num;
        } else {
            if (left != null) {
                nodeQueue.offer(left);
                numQueue.offer(num * 10 + left.val);
            }
            if (right != null) {
                nodeQueue.offer(right);
                numQueue.offer(num * 10 + right.val);
            }
        }
    }
    return sum;
}

方法三

private int result = 0;
public int sumNumbers(TreeNode root) {
    StringBuffer sb = new StringBuffer();
    dealNode(root, sb);
    return result;
}
private void dealNode(TreeNode root, StringBuffer sb) {
    if (root == null) {
        return;
    }
    sb.append(root.val);
    if (root.left == null && root.right == null) {
        result = result + Integer.valueOf(sb.toString());
    }
    dealNode(root.left, sb);
    dealNode(root.right, sb);
    sb.deleteCharAt(sb.length() - 1);
}

18. 二叉树的最近公共祖先：给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例：
在这里插入图片描述
输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if(root == null){
        return null;
    }
    if(root == p || root == q){
        return root;
    }
    TreeNode left = lowestCommonAncestor(root.left, p, q);
    TreeNode right = lowestCommonAncestor(root.right, p, q);
    if(left != null && right != null){
        return root;
    }
    if(left != null){
        return left;
    }
    if(right != null){
        return right;
    }
    return null;
}
孤独是人生的修行
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java程序员面试专栏 数据结构】五 高频面试算法题：二叉树
MaoLin Tian's Blog
11-20 288
一轮的算法训练完成后，对相关的题目有了一个初步理解了，接下来进行专题训练，以下这些题目就是二叉树相关汇总的高频题目。
Leetcode高频算法题：二叉树篇（一）
qq_22270363的博客
07-27 160
Leetcode高频算法题：二叉树篇（一）。有些题解是本人的原创解法。
LeetCode高频题：二叉树（二）
算法岗从零到无穷
01-27 218
我开了一个LeetCode会员，选择了一些高频率题目。这个系列是希望帮助大家每天花30分钟的题目了解面试高频题，让大家面试更加游刃有余。 本期我们讲解三道树的简单题。上期我们说到关于树的题目总是会跟递归扯上关系，而本期我们从递归入手，引出迭代的做法，比如说利用队列、栈等数据结构代替递归操作。本期所用的树的数据结构均如下： class TreeNode { int val; Tree...
Leetcode高频算法题：数组篇（一）
qq_22270363的博客
08-19 132
leetcode高频算法题：数组篇。部分题解是本人的原创解法
LeetCode算法题高频整理(精华篇)
Miracle8070
08-15 7718
1. 写在前面 之前刷题的时候，尝试把自己刷过的LeetCode算法题分类整理成了一个专栏算法刷题笔记，大约用14篇文章把算法题进行分类整理概括及总结，目前大约400道题目，本来想着秋招面试准备就反复刷这些就好，基本上能拿下80%的面试题。 但是发现400道量还是太多了，有很多刷过还总是忘，特别是数字找规律的那种， 并且我通过准备发现， 其实最常考和必会的并没有这么多， 面试官也是人呐， 考的肯定是他会的题目， 而太复杂的我们也都懂得哈哈。 所以这篇博客是整理在准备秋招面试刷题过程中，感觉出现的一些高频算法
Leetcode高频算法题——字节跳动篇
Erazer_Control
04-15 4807
众所周知，字节跳动面试非常喜欢考算法题。 Leetcode官方的企业题库不仅付费，而且题量非常大。 因此，我从20年7月开始，手动整理牛客面经涉及的Leetcode算法题，并按照频度由高到低进行了排列。以下列出的250多道高频题目。 如果你想查看按部门、岗位查看高频算法题，或者查看其他大厂的题库，可以使用我开发的CodeTop：https://codetop.cc 字节跳动题库已覆盖抖音、飞书、架构、data、商业变现、懂车帝、电商、今日头条等20多个部门。 字节跳动高频题（更新至2021年4.10日）
LeetCode高频题：二叉树
算法岗从零到无穷
01-26 194
我开了一个LeetCode会员，选择了一些高频率题目。这个系列是希望帮助大家每天花30分钟的题目了解面试高频题，让大家面试更加游刃有余。 本期我们讲解三道树的简单题。树的题目总是会跟递归扯上关系，而递归也是初学者最头疼的题目，因为不好在纸上演算，写着写着就搞混了。本期所用的树的数据结构均如下： class TreeNode { int val; TreeNode left; ...
LeetCode高频题：二叉树的锯齿形（Z字形，之字形）层序遍历
weixin_46838716的博客
07-21 771
1）普通的bfs二叉树层序遍历，非常简单，字节将队列不断从左往右加就行了 2）本题就是从1）改变来的，bfs队列控制，奇数层的时候，让加入队列的顺序从右往左，偶数层的时候，加入队列从左往右 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。.........
LeetCode高频题：二叉树（五）
算法岗从零到无穷
01-31 258
我开了一个LeetCode会员，选择了一些高频率题目。这个系列是希望帮助大家每天花30分钟的题目了解面试高频题，让大家面试更加游刃有余。 本期我们讲解两道树的中等题。我们之前几期的推送一直在强调递归和迭代，之前讲解的题目递归都比迭代简单，那么本期首先带来的就是迭代比递归更容易的题目。本期所用的树的数据结构均如下： class TreeNode { int val; TreeNode...
LeetCode高频算法面试题,含解题思路及代码实现
02-17
LeetCode高频算法面试题,含解题思路及代码实现
leetcode1004-leetcode:算法题
07-01
leetcode 1004 LeetCode JS LeetCode Algorithm # Title Solution Difficulty 1014 中等 1004 中等 950 中等 929 简单 739 中等 695 中等 674 简单 567 中等 557 简单 513 中等 503 中等 485 简单 445 中等 414 简单...
leetcode答案-Leetcode:Leetcode算法题，刷题心得
06-30
leetcode 答案 自己 Leetcode 刷题 的 代码 分各种类别 --》每个不同的数据结构、不同的算法思想 大都 记录了 自己的理解，心得 后期开始，也 督促下 自己 做题 要有 时间概念，所以 记录了 几个时间点 第一遍 做的...
leetcode题库-LeetCode:LeetCode算法：使用Java和kotlin
06-29
leetcode题库 LeetCode LeetCode算法：使用 Java 和 kotlin 进行解答 题库
leetcode题库-leetcode:算法代码-JavaScript
06-29
leetcode题库 leetcode 算法代码-JavaScript 本仓库，是leetcode题目的实现
算法训练营day41
stmfresher的博客
05-27 375
动态规划理论基础（主要就是确定动态规划的几个步骤）
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 537
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 718
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
图形学初识--空间变换
最新发布
航行的土豆的博客
05-29 874
介绍二维和三维下的变换矩阵以及常见的推导和理解方式。主要就是：平移、旋转、缩放
leetcode高频100题java
06-28
### 回答1： leetcode高频100题java是指LeetCode网站上的100道经典算法题目，使用Java语言进行解答。这些题目涵盖了各种算法和数据结构，包括数组、链表、树、图、排序、查找、动态规划等等。这些题目是程序员面试和算法学习的重要参考资料，也是提高编程能力和解决实际问题的有效途径。 ### 回答2： LeetCode是一个著名的程序员面试题库，其高频100题是指在面试中经常被问到的100道题目。这些题目涵盖了算法、数据结构、数学等各个领域，是程序员求职和成长过程中不可或缺的练习材料。本文将介绍这100题的Java解法。 这100题覆盖了许多经典算法，如动态规划、贪心算法、双指针等。对于Java程序员来说，最重要的是要掌握这些算法的核心思想及其实现方法。此外，Java核心类库中的一些常用类和函数，如String、Math、Arrays等也是解题过程中常用的工具。 对于高频100题，需要掌握的核心算法包括二分查找、数组和链表的操作、栈和队列、哈希表、递归等。此外，还需要掌握字符串操作、动态规划、贪心算法、回溯算法、深度/广度优先搜索等经典算法。 以数组和链表为例，需要掌握的操作包括数组的查找、排序和去重，以及链表的遍历、反转和合并等。使用Java语言来实现这些操作时，可以使用Java核心库中的Arrays和Collections类，它们提供了便捷的方法来处理数组和集合。 另外，Java语言还提供了众多数据结构，如栈、队列、双端队列、优先队列、堆等。这些数据结构可以进行复杂的算法操作，如优先队列可以实现贪心算法、堆可以实现堆排序等。Java还提供了Map和Set这两个关键字来实现哈希表的操作，使得开发人员可以轻松地实现哈希表。 最后，Java还提供了众多的工具类和常用函数，例如字符串操作函数、正则表达式、数学函数等。使用这些函数可以为算法提供更加便捷和高效的实现方法。 总之，掌握LeetCode高频100题的Java解法需要深入理解算法核心思想，灵活使用Java语言的各种工具和函数。在实际练习中，需要注重代码的可读性、复杂度和鲁棒性。 ### 回答3： LeetCode是全球最大的在线练习平台之一，通过解决LeetCode的问题，可以帮助人们提高他们的编程能力。在LeetCode上，有许多高频题，这些题目被认为是最重要的，因为这些题目经常在面试中出现。Java作为一种流行的编程语言，被大多数程序员所熟悉和使用。因此，LeetCode高频100题java是程序员们需要掌握的重要知识点。接下来，我将详细介绍LeetCode高频100题Java。 LeetCode高频100题java包括许多经典的算法和数据结构问题，例如：动态规划、回溯、DFS、BFS、二分查找、排序、链表、栈、队列、树、图等。每个问题都有一份完整的Java代码实现，以帮助程序员理解算法思路。不仅如此，Java代码还包括了详细的注释和解释，以帮助程序员更好地掌握算法。 LeetCode高频100题java对于Java程序员来说很重要，因为这些题目是在日常编码工作和面试中经常出现的问题。通过解决这些问题，程序员们能够提高他们的编码能力和思维能力。此外，这些问题也能帮助程序员们更好地了解Java语言的使用和优化，加深对Java语言特性的理解。 总结来说，对于Java程序员来说，掌握LeetCode高频100题java非常重要。这将帮助他们提高他们的编程水平，了解更多的算法和数据结构。通过解决这些问题，他们将更容易通过面试，获得更好的编程工作。因此，Java程序员们应该花费足够的时间和精力去学习和掌握LeetCode高频100题java。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值