怒刷LeetCode的第10天（Java版）

已于 2023-09-21 14:41:44 修改
阅读量260 收藏 2
点赞数 3
分类专栏： LeetCode算法 文章标签： leetcode 算法 职场和发展
于 2023-09-21 14:39:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74293254/article/details/133131887
版权

目录

第一题

题目来源

题目内容

解决方法

方法一：两次拓扑排序

第二题

题目来源

题目内容

解决方法

方法一：分治法

方法二：优先队列（Priority Queue）

方法三：迭代

第三题

题目来源

题目内容

解决方法

方法一：迭代

方法二：递归

方法三：双指针

方法四：栈

第一题

题目来源

2603. 收集树中金币 - 力扣（LeetCode）

题目内容

解决方法

方法一：两次拓扑排序

这个解法的思路如下：

  1. 首先，初始化一个邻接表 g，用于存储树的结构，以及一个数组 degree，用于记录每个节点的度数。
  2. 遍历边的数组 edges，将每条边的两个节点之间建立连接关系，并更新节点的度数。
  3. 初始化一个队列 queue，用于存储无金币的叶子节点。
  4. 遍历所有节点，如果一个节点的度数为1并且该节点没有金币，则将其加入队列。
  5. 开始循环，直到队列为空。在每次迭代中，取出队列的首个节点 u。
  6. 将节点 u 的度数减1，剩余节点数 rest 减1。
  7. 遍历与节点 u 相邻的所有节点 v，将其度数减1。
  8. 如果节点 v 的度数为1并且该节点没有金币，则将其加入队列。
  9. 重复步骤 5-8，直到队列为空。
  10. 重复两次以下步骤（总共遍历两次）： a. 初始化一个新的队列 queue。 b. 遍历所有节点，将度数为1的节点加入队列。 c. 开始循环，直到队列为空。 d. 取出队列的首个节点 u，将其度数减1，剩余节点数 rest 减1。 e. 遍历与节点 u 相邻的所有节点 v，将其度数减1。 f. 重复步骤 d-e，直到队列为空。
  11. 返回结果，如果剩余节点数 rest 为0，则路径长度为0；否则，路径长度为 (rest - 1) * 2。

这样，通过删除树中无金币的叶子节点和维护节点的度数，可以得到最小路径长度。

class Solution {
    public int collectTheCoins(int[] coins, int[][] edges) {
        int n = coins.length;
        List<Integer>[] g = new List[n];
        for (int i = 0; i < n; ++i) {
            g[i] = new ArrayList<Integer>();
        }
        int[] degree = new int[n];
        for (int[] edge : edges) {
            int x = edge[0], y = edge[1];
            g[x].add(y);
            g[y].add(x);
            ++degree[x];
            ++degree[y];
        }

        int rest = n;
        /* 删除树中所有无金币的叶子节点，直到树中所有的叶子节点都是含有金币的 */
        Queue<Integer> queue = new ArrayDeque<Integer>();
        for (int i = 0; i < n; ++i) {
            if (degree[i] == 1 && coins[i] == 0) {
                queue.offer(i);
            }
        }
        while (!queue.isEmpty()) {
            int u = queue.poll();
            --degree[u];
            --rest;
            for (int v : g[u]) {
                --degree[v];
                if (degree[v] == 1 && coins[v] == 0) {
                    queue.offer(v);
                }
            }
        }
        /* 删除树中所有的叶子节点, 连续删除2次 */
        for (int x = 0; x < 2; ++x) {
            queue = new ArrayDeque<Integer>();
            for (int i = 0; i < n; ++i) {
                if (degree[i] == 1) {
                    queue.offer(i);
                }
            }
            while (!queue.isEmpty()) {
                int u = queue.poll();
                --degree[u];
                --rest;
                for (int v : g[u]) {
                    --degree[v];
                }
            }
        }

        return rest == 0 ? 0 : (rest - 1) * 2;
    }
}

复杂度分析：

1、构建邻接表和计算节点度数的复杂度：

  • 遍历边的数组 edges，时间复杂度为 O(m)，其中 m 是边的数量。
  • 初始化邻接表 g 的空间复杂度为 O(n)，其中 n 是节点的数量。
  • 更新节点度数的过程需要遍历所有边，时间复杂度为 O(m)。

2、删除无金币叶子节点的过程的复杂度：

  • 初始化队列的时间复杂度为 O(n)，其中 n 是节点的数量。
  • 每个节点最多被处理一次，因此删除过程的时间复杂度为 O(n)。

3、连续删除两次叶子节点的过程的复杂度：

  • 需要进行两次完整的节点遍历，因此时间复杂度为 O(2n) = O(n)，其中 n 是节点的数量。

综上所述，整个解法的时间复杂度为 O(m + n)，其中 m 是边的数量，n 是节点的数量。空间复杂度为 O(n)，用于存储邻接表和节点度数。

LeetCode运行结果：

第二题

题目来源

23. 合并 K 个升序链表 - 力扣（LeetCode）

题目内容

解决方法

方法一：分治法

这是一个合并K个升序链表的问题，可以使用分治法来解决。使用了分治法来将k个链表分成两部分进行合并，然后再将合并后的结果继续与剩下的链表合并，直到最终合并成一个升序链表。在每个合并的过程中，可以使用双指针来逐个比较两个链表的节点值，将较小的节点连接到结果链表上。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }

        return merge(lists, 0, lists.length - 1);
    }

    private ListNode merge(ListNode[] lists, int start, int end) {
        if (start == end) {
            return lists[start];
        }

        int mid = start + (end - start) / 2;
        ListNode left = merge(lists, start, mid);
        ListNode right = merge(lists, mid + 1, end);

        return mergeTwoLists(left, right);
    }

    private ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        }
        if (l2 == null) {
            return l1;
        }

        if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

复杂度分析：

  • 这个解法的时间复杂度是 O(Nlogk)，其中 N 是所有链表的节点总数，k 是链表的数量。因为在每层合并的过程中，需要遍历 N 个节点来比较值，并且每次合并的链表数量减半，因此总共需要合并 logk 层。所以时间复杂度是 O(Nlogk)。
  • 空间复杂度是 O(logk)，主要是递归调用栈的空间。在每一层递归中，都会创建两个新的递归函数调用，所以递归的层数最多是 logk。因此，空间复杂度是 O(logk)。

需要注意的是，这里的空间复杂度是指除了返回的合并后的链表之外的额外空间使用量。

LeetCode运行结果：

方法二：优先队列（Priority Queue）

使用了优先队列来维护当前k个链表中的最小节点。首先，将所有链表的头节点加入到优先队列中。然后，不断从优先队列中取出最小的节点，将其加入到合并后的链表中，并将该节点的下一个节点加入到队列中。重复这个过程直到队列为空。 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }

        // 创建一个优先队列，按照节点值的大小进行排序
        PriorityQueue<ListNode> queue = new PriorityQueue<>((a, b) -> a.val - b.val);

        // 将所有链表的头节点加入到优先队列中
        for (ListNode node : lists) {
            if (node != null) {
                queue.offer(node);
            }
        }

        // 创建一个dummy节点作为合并后的链表头部
        ListNode dummy = new ListNode(0);
        ListNode curr = dummy;

        // 不断从优先队列中取出最小的节点，将其加入到合并后的链表中，然后将该节点的下一个节点加入到队列中
        while (!queue.isEmpty()) {
            ListNode node = queue.poll();
            curr.next = node;
            curr = curr.next;

            if (node.next != null) {
                queue.offer(node.next);
            }
        }

        return dummy.next;
    }
}

复杂度分析：

  • 这个基于优先队列的解法的时间复杂度是O(Nlogk)，其中N是所有链表的节点总数，k是链表的数量。主要的时间消耗在于构建优先队列和从队列中取出最小节点，而构建优先队列的时间复杂度是O(klogk)，每次取出最小节点的操作时间复杂度是O(logk)。由于总共需要取出N个节点，因此总体的时间复杂度是O(Nlogk)。
  • 空间复杂度是O(k)，主要是优先队列所占用的空间。在最坏情况下，优先队列中最多会有k个节点，因此空间复杂度是O(k)。

需要注意的是，这里的空间复杂度是指除了返回的合并后的链表之外的额外空间使用量。

LeetCode运行结果：

方法三：迭代

使用了迭代的方式逐一合并链表。

  1. 首先设定一个变量 interval，初始值为1，表示每次合并的链表数量。
  2. 然后进行循环，直到 interval 大于等于链表数组的长度。在每次循环中，按照 interval 的步长对链表数组进行逐一合并。每次合并两个链表，将合并结果放回原始数组的相应位置。
  3. 通过每次将 interval 值翻倍，循环进行迭代合并，直到 interval 大于等于链表数组的长度，最终得到合并后的链表。
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }
        
        int interval = 1;
        while (interval < lists.length) {
            for (int i = 0; i + interval < lists.length; i += 2 * interval) {
                lists[i] = mergeTwoLists(lists[i], lists[i + interval]);
            }
            interval *= 2;
        }
        
        return lists[0];
    }
    
    private ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode curr = dummy;
        
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                curr.next = l1;
                l1 = l1.next;
            } else {
                curr.next = l2;
                l2 = l2.next;
            }
            curr = curr.next;
        }
        
        if (l1 != null) {
            curr.next = l1;
        }
        
        if (l2 != null) {
            curr.next = l2;
        }
        
        return dummy.next;
    }
}

复杂度分析：

  • 时间复杂度：这个解法的时间复杂度是O(Nklogk)，其中N是每个链表的平均长度，k是链表的数量。通过每次将 interval 值翻倍，循环进行迭代合并，直到 interval 大于等于链表数组的长度，最终得到合并后的链表。在每一层循环中的操作总时间复杂度仍然是O(Nk)，因为每一层的合并操作需要遍历所有链表节点。
  • 空间复杂度：这个解法的空间复杂度是O(1)，没有使用额外的数据结构。只需要常数级别的额外空间来保存临时变量。

综上所述，优先队列解法和分治法解法的时间复杂度相同，但优先队列解法的空间复杂度略高于分治法解法。而迭代解法的时间复杂度稍高于前两种解法，并且空间复杂度较低。

LeetCode运行结果：

第三题

题目来源

24. 两两交换链表中的节点 - 力扣（LeetCode）

题目内容

解决方法

方法一：迭代

迭代的思路是遍历链表，每次处理两个相邻节点进行交换。具体步骤如下：

1、定义一个哑节点(dummy)作为新链表的头节点，并将其指向原始链表的头节点head。

2、定义一个指针prev指向哑节点，用于连接新链表中的节点。

3、当原始链表中至少有两个节点时，重复以下操作：

  • 使用指针curr1指向当前要交换的第一个节点，即prev.next。
  • 使用指针curr2指向当前要交换的第二个节点，即curr1.next。
  • 将prev的下一个节点指向curr2，完成节点交换。
  • 将curr1的下一个节点指向curr2的下一个节点，完成节点交换。
  • 将curr2的下一个节点指向curr1，完成节点交换。
  • 更新prev指针和curr1指针，使它们分别指向交换后的第二个节点和下一组要交换的第一个节点。

4、返回哑节点(dummy)的下一个节点作为新链表的头节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode swapPairs(ListNode head) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode prev = dummy;
    
    while (head != null && head.next != null) {
        ListNode curr1 = head;
        ListNode curr2 = head.next;
        
        prev.next = curr2;
        curr1.next = curr2.next;
        curr2.next = curr1;
        
        prev = curr1;
        head = curr1.next;
    }
    
    return dummy.next;
}

}

复杂度分析：

  • 时间复杂度：O(n)，其中n是链表中的节点数。需要遍历链表中的每个节点一次。
  • 空间复杂度：O(1)。只需要常数级别的额外空间。

LeetCode运行结果：

方法二：递归

递归的思路是将链表分成两部分：第一个节点和剩余节点。然后，交换这两部分，并递归地对剩余节点进行两两交换。具体步骤如下：

  1. 当链表为空或只有一个节点时，无需交换，直接返回该节点。
  2. 令first指向链表的头节点，second指向first的下一个节点。
  3. 交换first和second节点，即将second的next指向first，并将first的next指向递归处理剩余节点的结果。
  4. 返回second节点作为新链表的头节点。
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode swapPairs(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    
    ListNode first = head;
    ListNode second = head.next;
    
    first.next = swapPairs(second.next);
    second.next = first;
    
    return second;
}
}

复杂度分析：

  • 时间复杂度：O(n)，其中n是链表中的节点数。每次递归都会处理一个节点，并且递归调用的层数最多为n/2。
  • 空间复杂度：O(n)，其中n是链表中的节点数。递归调用的栈空间最多为n/2。

LeetCode运行结果：

方法三：双指针

除了递归和迭代之外，还可以使用双指针的方法来交换链表中的节点。该方法使用两个指针prev和curr分别指向当前要交换的两个节点的前一个节点和第一个节点。通过不断地交换节点，并更新指针，实现链表中节点的两两交换。

注意：它与迭代方法的思路类似，但在细节上有所改动。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode swapPairs(ListNode head) {
    // 创建哑节点(dummy)作为新链表的头节点，并将其指向原始链表的头节点head
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    
    // 定义两个指针prev和curr，分别指向当前要交换的两个节点的前一个节点和第一个节点
    ListNode prev = dummy;
    ListNode curr = head;
    
    while (curr != null && curr.next != null) {
        // 获取要交换的两个节点
        ListNode node1 = curr;
        ListNode node2 = curr.next;
        
        // 进行节点交换
        prev.next = node2;
        node1.next = node2.next;
        node2.next = node1;
        
        // 更新prev和curr指针，进行下一组节点交换
        prev = node1;
        curr = node1.next;
    }
    
    return dummy.next;
}

}

复杂度分析：

  • 时间复杂度：O(n)  遍历链表中的每个节点一次，所以时间复杂度是线性的。
  • 空间复杂度：O(1)  只使用了常数级别的额外空间，不随输入规模增加而变化。

LeetCode运行结果：

方法四：栈

除了递归、双指针和迭代之外，还可以使用栈来实现链表节点的两两交换。

这种栈的方法将链表中的节点依次入栈，每次栈中至少有两个节点时，就进行交换操作。通过维护栈来实现链表节点的两两交换。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode swapPairs(ListNode head) {
    // 创建一个栈
    Deque<ListNode> stack = new ArrayDeque<>();
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    
    ListNode curr = dummy;
    
    while (curr != null && curr.next != null) {
        // 将当前节点的后继节点和后继的后继节点入栈
        stack.push(curr.next);
        stack.push(curr.next.next);
        
        // 当栈中至少有两个节点时，进行节点交换
        if (stack.size() >= 2) {
            curr.next = stack.pop();
            curr.next.next = stack.pop();
            curr = curr.next.next;
        } else {
            break;
        }
    }
    
    return dummy.next;
}

}

复杂度分析：

  • 时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表中的每个节点一次。
  • 空间复杂度：O(n)，需要使用一个栈来存储节点。

需要注意的是，递归的深度与链表的长度相关，当链表较长时可能会导致栈溢出，因此在实际使用时需要注意链表的长度限制。如果链表长度较大，建议使用其他方法实现节点的交换。

LeetCode运行结果：

正在奋斗的程序猿
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode:LeetCode代码（Java版）
06-30
《LeetCode：深入解析Java版解题策略》 在编程领域，LeetCode 是一个极受欢迎的在线平台，它提供了一系列的编程挑战，旨在提升开发者们的算法技能和问题解决能力。本篇文章将聚焦于使用Java语言在LeetCode上的解题...
刷LeetCode刷LeetCode刷LeetCode刷LeetCode
01-09
《刷LeetCode刷LeetCode刷LeetCode刷LeetCode》这个标题和描述虽然重复，但很明显是在强调通过反复练习LeetCode来提升编程技能的重要性。LeetCode是一个在线平台，它提供了大量的编程题目，涵盖算法、数据结构等多种...
怒刷LeetCode的第26天（Java版）
m0_74293254的博客
10-10 452
整数状态：在这个状态下，输入了数字 0-9。小数点状态：在这个状态下，已经输入了小数点。小数状态：在这个状态下，已经输入了数字并带有小数点。幂符号状态：在这个状态下，出现了字符 e 或 E。幂符号后的符号位状态：在这个状态下，出现了符号位 + 或 -。幂符号后的整数状态：在这个状态下，输入了数字 0-9。终止状态：如果当前输入的字符不合法或者最后一步能够到达终止状态，则说明输入是一个合法的数字。如果所有位都需要进位，则返回新的结果数组，长度为原数组长度加一，首位为1，其余位为0。方法一：有限状态自动机。
怒刷LeetCode的第6天（Java版）
m0_74293254的博客
09-18 408
时间复杂度为O(mnlogn)，其中m是字符串的平均长度，n是字符串数组的长度。时间复杂度为O(mn)，其中m是最长公共前缀的长度，n是字符串数组的长度。空间复杂度为O(1)。时间复杂度为O(mn)，其中m是最短字符串的长度，n是字符串数组的长度。该算法使用二分查找来逐步缩小最长公共前缀的范围，时间复杂度为O(mnlogm)，其中m是最短字符串的长度，n是字符串数组的长度。如果当前索引位置超过了当前字符串的长度，或者当前字符在其他字符串的相同位置上的字符不相等，则表示不匹配，直接返回当前的公共前缀。
怒刷LeetCode的第15天（Java版）
m0_74293254的博客
09-25 572
第一题题目来源解决方法方法一：哈希表+双向链表LFU（Least Frequently Used）缓存算法的主要思想是根据键的使用频率来进行缓存项的管理。首先，我们需要设计一个数据结构来存储缓存的键值对，并记录每个键的使用计数（即使用频率）。为了支持 O(1) 的时间复杂度，我们可以使用哈希表来存储键值对，并且使用双向链表来维护具有相同使用计数的键的顺序。values因此，get 和 put 操作的时间复杂度都是 O(1)。因此，LFU 缓存算法的空间复杂度为 O(capacity)。
怒刷LeetCode的第3天（Java版）
m0_74293254的博客
09-17 315
对于第一种情况，dp[i] = max(dp[i-2] + nums[i], dp[i-1])，其中dp[i-2] + nums[i]表示偷窃第i个房屋得到的金额，dp[i-1]表示不偷窃第i个房屋得到的金额。对于第二种情况，dp[i] = max(dp[i-1], dp[i-2] + nums[i])，其中dp[i-1]表示不偷窃第i个房屋得到的金额，dp[i-2] + nums[i]表示偷窃第i个房屋得到的金额。综上所述，该解法的时间复杂度和空间复杂度都是O(n)，其中n为字符串s的长度。
怒刷LeetCode的第14天（Java版）
m0_74293254的博客
09-23 195
因此，最多需要遍历整个数组一次，时间复杂度为 O(n)。因为二分查找的时间复杂度为 log n，而线性扫描的时间复杂度为 n，所以在数组较大且已排序的情况下，二分查找的性能更好。综合考虑，递归搜索旋转排序数组的算法在最坏情况下的时间复杂度为 O(n)，空间复杂度为 O(log n)。需要注意的是，双指针法适用于有序数组或部分有序数组，如果数组无序，则双指针法无法正确找到目标值的开始位置和结束位置。综上所述，线性扫描算法适用于简单的问题或者规模较小的数据集，但在更大规模的数据集上，二分查找算法通常更具优势。
怒刷LeetCode的第4天（Java版）
m0_74293254的博客
09-17 179
然后，我们检查 num 是否超出了整数的范围，并根据结果返回相应的值。这个函数首先去除字符串的前导空格，然后判断字符串是否为空或只有正负号的情况，如果是，则返回0。然后，遍历字符串的剩余部分，将连续的数字字符转换为整数，并判断是否超出范围。需要注意的是，在判断是否超出范围时，我们使用了长整型变量 result，而不是直接使用整型变量。这个算法的时间复杂度是 O(m * n)，其中 m 是字符串 s 的长度，n 是模式 p 的长度。这个方法的时间复杂度是 O(log n)，其中 n 是 x 的位数。
怒刷LeetCode的第1天（Java版）
m0_74293254的博客
09-16 207
如果存在，则说明之前遍历过的某个数字与当前数字的和等于目标值，就返回这两个数字的索引。2、状态转移方程：dp[i] = max(dp[i-2]+nums[i], dp[i-1])，表示选择偷当前房间和前两个房间的收益之和与不偷当前房间的收益中的较大值。同时，通过使用哈希表来存储数字和索引的映射关系，可以在 O(1) 的时间复杂度内快速查找差值是否已存在。该算法的时间复杂度为 O(n^2)，因为需要遍历每对不同的数字。空间复杂度分析： 需要一个长度为n的数组来存储中间结果，因此空间复杂度为O(n)。
怒刷LeetCode的第18天（Java版）
m0_74293254的博客
09-28 203
对于数组中的每个位置，如果栈为空或者当前位置的高度小于等于栈顶位置的高度，则将当前位置的下标入栈；需要注意的是，最终的字符串结果需要消除前导零，但是在最坏的情况下，结果字符串的长度可能达到 m + n。需要注意的是，这种方法利用了BigInteger类的内置函数，因此不符合题目要求"不能使用任何内置的 BigInteger 库或直接将输入转换为整数"，但是效率上会更高。与置换的方法相比，使用哈希集合的方法在时间复杂度和空间复杂度上都是一样的，但它使用了额外的哈希集合来存储正整数。
怒刷LeetCode的第5天（Java版）
m0_74293254的博客
09-18 151
如果我们将左指针向右移动一位，那么新的左指针对应的线段高度为 l'，右指针不变，那么新容器的底部长度为 r- (l'-l)，高度为 min(l', r)，因此容器容纳的水量为 (r-(l'-l)) * min(l', r)。计算某个元素时，可以考虑当前两条线段的高度和它们之间的距离，并且选择高度较小的一条作为瓶颈，即容器的高度，并计算容器的底部长度，即线段的距离。然后，从大到小遍历符号数组，每次查看给定的整数中有多少个当前符号所对应的数值，将其加入结果字符串，并用给定的整数减去已经加过的数值。
用java刷leetcode-leetcode:leetcode
07-01
用java刷leetcode leetcode 虽然刷题被诟病已久，但不可否认，刷题确实可以锻炼我们的编程能力，相信每一个认真的刷题都会有经验。 在线编程评测的平台有很多，比如hihocoder、lintcode、leetcode，我们这里重点介绍...
leetcode-java:java版本的leetcode
07-23
《LeetCode Java版详解》 LeetCode 是一个广受欢迎的在线编程挑战平台，它提供了丰富的算法和数据结构问题，帮助开发者提升编程技能和解决实际问题的能力。本篇将重点介绍LeetCode上的Java版本实现，旨在深入理解...
Leetcode:leetcode题解 Java版
05-11
这个压缩包“Leetcode: leetcode题解 Java版”显然包含了使用Java语言解决LeetCode上算法问题的代码库。让我们深入探讨一下这个主题，特别是与Java相关的知识点。 1. **Java基础语法**：在解决LeetCode问题时，首先...
Golang | Leetcode Golang题解之第284题窥视迭代器
weixin_66442839的博客
07-25 523
Golang | Leetcode Golang题解之第284题窥视迭代器
LeetCode 2766.重新放置石块：哈希表
<font color="Pink">Tisfy的博客</font>
07-25 839
LeetCode 2766.重新放置石块：哈希表 给你一个下标从 0 开始的整数数组 nums ，表示一些石块的初始位置。再给你两个长度 相等 下标从 0 开始的整数数组 moveFrom 和 moveTo 。 在 moveFrom.length 次操作内，你可以改变石块的位置。在第 i 次操作中，你将位置在 moveFrom[i] 的所有石块移到位置 moveTo[i] 。 完成这些操作后，请你按升序返回所有 有 石块的位置。 注意： 如果一个位置至少有一个石块，我们称这个位置 有 石块。 一个位
Java | Leetcode Java题解之第284题窥视迭代器
m0_57195758的博客
07-25 423
Java | Leetcode Java题解之第284题窥视迭代器
C++——从前序与中序遍历序列构造二叉树leetcode105
最新发布
qq_50737873的博客
07-26 280
来源于leetcode官方解答，先序遍历的排布是[根节点，左子树，右子树]，中序遍历的排布是[左子树，根节点，右子树]，因此，从先序第一个元素可以找到中序中的根节点的位置，从而可以确定出左子树和右子树的节点数目，从而可以正确划分这一级的先序遍历的左右子树，对于左右子树内部也是对应的排列方式，因此可以考虑迭代，每次更新先序遍历和中序遍历的左右边界。preorder 和 inorder 均 无重复 元素。preorder 保证 为二叉树的前序遍历序列。inorder 均出现在 preorder。
java刷leetcode可以吗
06-09
当然可以！...使用Java刷LeetCode有很多好处，例如Java具有良好的跨平台性，易于学习和使用，拥有很多现成的库和框架等等。因此，如果您熟悉Java编程语言，那么使用Java刷LeetCode是一个不错的选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

正在奋斗的程序猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值