feat: 更新题解1.两数之和

Author: suukii

README.md

@@ -111,7 +111,7 @@
 
 ### 哈希表
 
--   [x] [【day-19】1.两数之和](./basic/day-19.md)
+-   [x] [【day-19】1.两数之和](./basic/hashmap/19.two-sum.md)
 -   [x] [【day-20】447.回旋镖的数量](./basic/day-20.md)
 -   [ ] 【day-21】36.有效的数独
 -   [x] [【day-22】645.错误的集合](./basic/day-22.md)

basic/day-18.md

@@ -0,0 +1,172 @@
+# 1. 两数之和
+
+https://leetcode-cn.com/problems/two-sum
+
+- [1. 两数之和](#1-两数之和)
+  - [题目描述](#题目描述)
+  - [方法 1：哈希表](#方法-1哈希表)
+    - [思路](#思路)
+    - [复杂度分析](#复杂度分析)
+    - [代码](#代码)
+  - [方法 2：排序+双指针](#方法-2排序双指针)
+    - [思路](#思路-1)
+    - [复杂度分析](#复杂度分析-1)
+    - [代码](#代码-1)
+  - [方法 3：暴力法](#方法-3暴力法)
+    - [思路](#思路-2)
+    - [复杂度分析](#复杂度分析-2)
+    - [代码](#代码-2)
+
+## 题目描述
+
+```
+给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
+
+你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
+
+
+
+示例:
+
+给定 nums = [2, 7, 11, 15], target = 9
+
+因为 nums[0] + nums[1] = 2 + 7 = 9
+所以返回 [0, 1]
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/two-sum
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+```
+
+## 方法 1：哈希表
+
+### 思路
+
+在遍历数组的同时把数字和下标存进哈希表中，然后看 `目标值 - 当前数字` 是否存在于哈希表中，有的话直接返回结果，没有就继续遍历。
+
+由于不能使用同一个元素，要注意先检查，再将当前数字加入哈希表。
+
+### 复杂度分析
+
+-   时间复杂度：$O(N)$，N 为数组长度，最坏的情况下数组中的每个元素都被访问一次，访问数组元素的时间是 $O(1)$，哈希表插入和查询元素的时间也是 $O(1)$。
+-   空间复杂度：$O(N)$，N 为数组长度，用来存元素和下标的哈希表所需的空间。
+
+### 代码
+
+JavaScript Code
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+    if (!nums || !nums.length) return [];
+
+    const map = {};
+    for (let i = 0; i < nums.length; i++) {
+        const num = nums[i];
+        const diff = target - num;
+
+        if (diff in map) return [map[diff], i];
+        map[num] = i;
+    }
+};
+```
+
+Python Code
+
+```py
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        hashmap = {}
+        for i, n in enumerate(nums):
+            diff = target - n
+            if diff in hashmap:
+                return [hashmap[diff], i]
+            hashmap[n] = i
+```
+
+## 方法 2：排序+双指针
+
+### 思路
+
+-   先给数组排序，再用双指针查找。
+-   不过题目要求返回下标，所以排序之前还需要保存原本的下标。
+
+### 复杂度分析
+
+-   时间复杂度：$O(NlogN)$，N 为数组长度。
+-   空间复杂度：$O(1)$。（不是很确定，是 $O(1)$ 还是 $O(N)$）
+
+### 代码
+
+JavaScript Code
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+    if (!nums || !nums.length) return [];
+
+    // 保存原来的下标，然后升序排序，nums 中元素的格式是 [num, index]
+    // [2,7,11,15] => [[2, 0], [7, 1], [11, 2], [15, 3]]
+    nums = nums.map((n, i) => [n, i]);
+    nums.sort((a, b) => a[0] - b[0]);
+
+    let l = 0,
+        r = nums.length - 1;
+    while (l < r) {
+        const n1 = nums[l][0],
+            n2 = nums[r][0];
+
+        if (n1 + n2 === target) return [nums[l][1], nums[r][1]];
+
+        // 太大了，右指针左移
+        if (n1 + n2 > target) r--;
+        // 太小了，左指针右移
+        else l++;
+    }
+};
+```
+
+## 方法 3：暴力法
+
+### 思路
+
+暴力法也顺便做一下吧。
+
+### 复杂度分析
+
+-   时间复杂度：$O(N^2)$，N 为数组长度。
+-   空间复杂度：$O(1)$。
+
+### 代码
+
+JavaScript Code
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+    if (!nums || !nums.length) return [];
+
+    for (let i = 0; i < nums.length; i++) {
+        for (let j = i + 1; j < nums.length; j++) {
+            if (nums[i] + nums[j] === target) return [i, j];
+        }
+    }
+};
+```