add 1,2,3.

Author: likeke1997

1.两数之和.js

@@ -0,0 +1,28 @@
+/*
+ * @lc app=leetcode.cn id=1 lang=javascript
+ *
+ * [1] 两数之和
+ * 1.双层循环的时间复杂度为O(n^2)，效率很低。
+ *   利用哈希表来存放整数及其下标，能使寻找整数下标的时间复杂度降为O(1)，
+ *   即相当于减少了一层循环，整体的时间复杂度变为O(n)。
+ * 2.如果没有符合要求的整数，可返回[-1,-1]。
+ */
+
+// @lc code=start
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+  const numsHash = {};
+  for (let i = 0; i < nums.length; i++) {
+    const num1 = nums[i],
+      num2 = target - num1,
+      j = numsHash[num2];
+    if (j !== undefined) return [i, j];
+    numsHash[num1] = i;
+  }
+  return [-1, -1];
+};
+// @lc code=end

2.两数相加.js

@@ -0,0 +1,43 @@
+/*
+ * @lc app=leetcode.cn id=2 lang=javascript
+ *
+ * [2] 两数相加
+ * 1.因为链表中的位数为逆序，所以应顺序相加链表。
+ * 2.注意处理有进位的情况。
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function (l1, l2) {
+  const list = new ListNode(0);
+  let head = list,
+    carry = false;
+  while (l1 !== null || l2 !== null || carry) {
+    let sum = Number(carry);
+    if (l1 !== null) {
+      sum += l1.val;
+      l1 = l1.next;
+    }
+    if (l2 !== null) {
+      sum += l2.val;
+      l2 = l2.next;
+    }
+    carry = sum >= 10;
+    sum = carry ? sum - 10 : sum;
+    head.next = new ListNode(sum);
+    head = head.next;
+  }
+  return list.next;
+};
+// @lc code=end

20.有效的括号.js

@@ -0,0 +1,26 @@
+/*
+ * @lc app=leetcode.cn id=20 lang=javascript
+ *
+ * [20] 有效的括号
+ * 1.遇到左括号时，该括号入栈
+ * 2.遇到右括号时，如该括号与栈顶括号对应，则出栈，否则返回false
+ * 3.最后判断栈长度是否为0，如果不为0，返回true
+ */
+
+// @lc code=start
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function (s) {
+  const stack = [],
+    lefts = ["(", "{", "["],
+    rights = [")", "}", "]"];
+  for (let char of s) {
+    const [i, j] = [lefts.indexOf(char), rights.indexOf(char)];
+    if (i !== -1) stack.push(i);
+    else if (j !== stack.pop()) return false;
+  }
+  return stack.length === 0;
+};
+// @lc code=end

3.无重复字符的最长子串.js

@@ -0,0 +1,29 @@
+/*
+ * @lc app=leetcode.cn id=3 lang=javascript
+ *
+ * [3] 无重复字符的最长子串
+ * 1.用哈希表存放字符及其下标。遍历s时，可借此判断是否出现重复字符。
+ *   当前字符下标i减去重复字符下标j，即是以当前字符为末端字符的无重复字符子串的长度len。
+ * 2.因为j只能往右走，所以当新j大于旧j时，才更新j。j初始为-1。
+ * 3.用max表示结果，max初始为0。如果len大于max，才更新max。
+ */
+
+// @lc code=start
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function (s) {
+  const charHash = {};
+  let left = -1,
+    max = 0;
+  for (let i = 0; i < s.length; i++) {
+    const char = s[i],
+      j = charHash[char];
+    if (j !== undefined && j > left) left = j;
+    max = Math.max(max, i - left);
+    charHash[char] = i;
+  }
+  return max;
+};
+// @lc code=end

4.寻找两个正序数组的中位数.js

@@ -0,0 +1,40 @@
+/*
+ * @lc app=leetcode.cn id=4 lang=javascript
+ *
+ * [4] 寻找两个正序数组的中位数
+ * 1.既然要求时间复杂度为O(log(m+n))，那么应该想到二分法。
+ *   思路比较巧妙，三言两语讲不清楚，建议直接看官方题解。
+ */
+
+// @lc code=start
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var findMedianSortedArrays = function (nums1, nums2) {
+  // 把短的数组放前面，便于后面比较
+  const len1 = nums1.length,
+    len2 = nums2.length;
+  if (len1 > len2) return findMedianSortedArrays(nums2, nums1);
+  // 如果总长度为奇数，则第k个数为中位数
+  // 如果总长度为偶数，则第k和第k+1个数为中位数
+  const K = ((len1 + len2) / 2) >> 1;
+  let k = K,
+    i = (k >> 1) - 1,
+    j = (k >> 1) - 1,
+    num1,
+    num2;
+  while (i + j + 1 < K) {
+    i = Math.min(len1 - 1, i);
+    j = Math.min(len2 - 1, j);
+    num1 = nums1[i];
+    num2 = nums2[j];
+    k = K - i - j;
+    if (num1 >= num2) j += k >> 2;
+    else i += k >> 2;
+  }
+  console.log(K, k, i, j);
+  return 0;
+};
+// @lc code=end

94.二叉树的中序遍历.js

@@ -0,0 +1,35 @@
+/*
+ * @lc app=leetcode.cn id=94 lang=javascript
+ *
+ * [94] 二叉树的中序遍历
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var inorderTraversal = function (root) {
+  /* 迭代 */
+  const rets = [];
+
+  /* 递归
+  const rets = [];
+  if (root !== null) traverse(root);
+  function traverse(root) {
+    const { val, left, right } = root;
+    if (left !== null) traverse(left);
+    rets.push(val);
+    if (right !== null) traverse(right);
+  }
+  return rets;
+  */
+};
+// @lc code=end

README.md

@@ -0,0 +1,30 @@
+## 说明
+
+这是我的 LeetCode 题解。
+
+以`1.两数之和.js`为例，对文件格式进行说明：
+
+```js
+/*
+ * @lc app=leetcode.cn id=1 lang=javascript
+ *
+ * 【编号】【题目】
+ * [1] 两数之和
+ * 【解题思路】
+ * 1.双层循环的时间复杂度为O(n^2)，效率很低。
+ *   利用哈希表来存放整数及其下标，能使寻找整数下标的时间复杂度降为O(1)，
+ *   即相当于减少了一层循环，整体的时间复杂度变为O(n)。
+ * 2.如果没有符合要求的整数，可返回[-1,-1]。
+ */
+
+// @lc code=start
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+  // 【代码】
+};
+// @lc code=end
+```

leetcode-solutions.code-workspace

@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"name": "leetcode-solutions",
+			"path": "."
+		}
+	]
+}