From 071c6288b4b424df948f06f29f2c17c8388c4e02 Mon Sep 17 00:00:00 2001 From: CharonChui Date: Sat, 12 Oct 2024 17:29:06 +0800 Subject: [PATCH] update --- ...44\346\225\260\344\271\213\345\222\214.md" | 27 ++++++------- ...44\346\225\260\347\233\270\345\212\240.md" | 40 +++++++++---------- 2 files changed, 33 insertions(+), 34 deletions(-) diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md" index 72102238..b5d71dba 100644 --- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md" +++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md" @@ -1,24 +1,28 @@ 1. LeetCode_两数之和 === -给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 +给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 +--- -示例 1： +示例 1 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 + + 示例 2： 输入：nums = [3,2,4], target = 6 输出：[1,2] -示例 3： + +示例 3： 输入：nums = [3,3], target = 6 输出：[0,1] @@ -27,9 +31,6 @@ 提示： -2 <= nums.length <= 104 --109 <= nums[i] <= 109 --109 <= target <= 109 只会存在一个有效答案 @@ -89,11 +90,11 @@ public: ### 方法二： 哈希表 -注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。 +注意到方法一的时间复杂度较高的原因是寻找target - x的时间复杂度过高。 因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。 -使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。 +使用哈希表，可以将寻找target - x的时间复杂度降低到从O(N)降低到O(1)。 --- @@ -104,17 +105,15 @@ public: - key: 存储数组里的值 - value: 存储数组的下标index -这样我们只需要通过target - nums[i]的值去Map中查找即可。 -但是这样存在一个问题，就是你需要先把数组中的值都放到Map中，需要多一步循环。 - - +这样我们只需要通过target - nums[i]的值去Map中查找即可。 +但是这样存在一个问题，就是你需要先把数组中的值都放到Map中，需要多一步循环。 --- -其实我们可以先创建一个Map，在Map的初始化过程中什么元素都不放。 +其实我们可以先创建一个Map，在Map的初始化过程中什么元素都不放。 -对于每一个 x，我们首先查询哈希表中是否存在 target - x，如果已存在就返回，如果不存在那再将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。 +对于每一个x，我们首先查询哈希表中是否存在target-x，如果已存在就返回，如果不存在那再将x插入到哈希表中，即可保证不会让x和自己匹配。 这样只需要一次循环就可以了，而且Map数组不用提前初始化，在性能和内存占用率都比较低。 diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md" index 789a2a9f..03581f19 100644 --- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md" +++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md" @@ -1,11 +1,11 @@ -2. LeetCode_两数相加 +2. LeetCode_两数相加 === -给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 +给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 -你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 +你可以假设除了数字0之外，这两个数都不会以0开头。 输入：l1 = [2,4,3], l2 = [5,6,4] @@ -18,31 +18,31 @@ 输出：[8,9,9,9,0,0,0,1] -提示： +提示: -- 每个链表中的节点数在范围 [1, 100] 内 +- 每个链表中的节点数在范围[1, 100]内 - 0 <= Node.val <= 9 - 题目数据保证列表表示的数字不含前导零 -想法： +想法: 我的想法是先把两个链表转成两个整数相加，然后把这个整数转成字符串再次生成链表。 这种方案是不可行的，因为链表的长度可能会很长，整数是操作不了的，例如: -方法： +方法: -由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。 +- 由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。 -我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry，则它们的和为 n1+n2+carry； +- 我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry，则它们的和为 n1+n2+carry； 其中，答案链表处相应位置的数字为 (n1+n2+carry)mod10，而新的进位值为 [(n1+n2+carry) / 10] -如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 0 。 +- 如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 0 。 -此外，如果链表遍历结束后，有 carry>0，还需要在答案链表的后面附加一个节点，节点的值为 carry。 +- 此外，如果链表遍历结束后，有carry>0，还需要在答案链表的后面附加一个节点，节点的值为 carry。 @@ -50,12 +50,12 @@ ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_2_twoaddsum.png?raw=true) -- 将链表反过来看，头结点在右侧 -- 横线上的数字为进位 -- 2 + 5 + 0(第一个进位默认为0) = 7 +- 将链表反过来看，头结点在右侧 +- 横线上的数字为进位 +- 2 + 5 + 0(第一个进位默认为0) = 7 - - 7 % 10得到新节点中的元素为7 - - 7 / 10得到下一个进位为0 + - 7 % 10得到新节点中的元素为7 + - 7 / 10得到下一个进位为0 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_2_twoaddsum_2.png?raw=true) @@ -123,11 +123,11 @@ class Solution { -复杂度分析: +复杂度分析: -- 时间复杂度：O(max(m,n))，其中 m 和 n 分别为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要 O(1) 的时间。 +- 时间复杂度: O(max(m,n))，其中m和n分别为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要O(1)的时间。 -- 空间复杂度：O(1)。注意返回值不计入空间复杂度。 +- 空间复杂度: O(1)。注意返回值不计入空间复杂度。 ### 改进： 递归 @@ -139,7 +139,7 @@ class Solution { } } - public ListNode add(ListNode l1, ListNode l2, int carry) { +public ListNode add(ListNode l1, ListNode l2, int carry) { if (l1 == null && l2 == null && carry == 0) { return null; }