GitBook: [master] 188 pages modified

Author: 6boris

SUMMARY.md

@@ -0,0 +1,2 @@
+# 0001.Two-Sum
+

docs/leetcode/1-100/0001.two-sum.md

@@ -0,0 +1,65 @@
+# 0002.Add-Two-Numbers
+
+## Description
+
+You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in **reverse order** and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+**Example**
+
+```text
+Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 0 -> 8
+Explanation: 342 + 465 = 807.
+```
+
+**Tags:** Linked List, Math
+
+## 题意
+
+> 以链表表示一个数，低位在前，高位在后，所以题中的例子就是 342 + 465 = 807.
+
+## 题解
+
+### 思路1
+
+> 直接模拟计算就好
+
+```go
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+    node := &ListNode{Val: 0, Next: nil}
+    n1, n2, tmp := l1, l2, node
+    sum := 0
+
+    for n1 != nil || n2 != nil {
+        sum /= 10
+        if n1 != nil {
+            sum += n1.Val
+            n1 = n1.Next
+
+        }
+        if n2 != nil {
+            sum += n2.Val
+            n2 = n2.Next
+        }
+        tmp.Next = &ListNode{Val: sum % 10}
+        tmp = tmp.Next
+    }
+    if sum/10 != 0 {
+        tmp.Next = &ListNode{Val: 1}
+    }
+    return node.Next
+}
+```
+
+### 思路2
+
+> 思路2 \`\`\`go
+
+\`\`\`
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-leetcode](https://github.com/kylesliu/awesome-golang-algorithm)
+

docs/leetcode/1-100/0002.add-two-numbers.md

@@ -0,0 +1,111 @@
+# 0003.Longest-Substring-Without-Repeating-Characters
+
+## Description
+
+## Description
+
+Given a string, find the length of the **longest substring** without repeating characters.
+
+**Examples:**
+
+Given `"abcabcbb"`, the answer is `"abc"`, which the length is 3.
+
+Given `"bbbbb"`, the answer is `"b"`, with the length of 1.
+
+Given `"pwwkew"`, the answer is `"wke"`, with the length of 3. Note that the answer must be a **substring**, `"pwke"` is a _subsequence_ and not a substring.
+
+**Tags:** Hash Table, Two Pointers, String
+
+## 题意
+
+> 计算不带重复字符的最长子字符串的长度
+
+## 题解
+
+### 思路1
+
+> 开辟一个 hash 数组来存储该字符上次出现的位置，比如 `hash[a] = 3` 就是代表 `a` 字符前一次出现的索引在 3，遍历该字符串，获取到上次出现的最大索引（只能向前，不能退后），与当前的索引做差获取的就是本次所需长度，从中迭代出最大值就是最终答案。
+
+```go
+// O(n) time O(1) space Solution
+func lengthOfLongestSubstring(s string) int {
+    var chPosition [256]int // [0, 0, 0, ...]
+    maxLength, substringLen, lastRepeatPos := 0, 0, 0
+
+    for i := 0; i < len(s); i++ {
+        if pos := chPosition[s[i]]; pos > 0 {
+            // record current substring length
+            maxLength = Max(substringLen, maxLength)
+
+            // update characters position
+            chPosition[s[i]] = i + 1
+
+            // update last repeat character position
+            lastRepeatPos = Max(pos, lastRepeatPos)
+
+            // update the current substring from last repeat character
+            substringLen = i + 1 - lastRepeatPos
+        } else {
+            substringLen += 1
+            chPosition[s[i]] = i + 1
+        }
+    }
+
+    return Max(maxLength, substringLen)
+}
+func Max(x, y int) int {
+    if x > y {
+        return x
+    }
+    return y
+}
+```
+
+### 思路2
+
+> 暴力循环
+>
+> \`\`\`go // 暴力求解\(会超时\) func lengthOfLongestSubstring2\(s string\) int { ans := 0
+
+```text
+for i := 0; i < len(s); i++ {
+    for j := i + 1; j <= len(s); j++ {
+        if allUnique(s, i, j) {
+            ans = Max(ans, j-i)
+        }
+    }
+}
+return ans
+```
+
+}
+
+func allUnique\(s string, start int, end int\) bool { sMap := make\(map\[string\]int\)
+
+```text
+for i := start; i < end; i++ {
+    if sMap[string(s[i])] > 0 {
+        return false
+    }
+    sMap[string(s[i])]++
+}
+
+return true
+```
+
+}
+
+func Max\(x, y int\) int { if x &gt; y { return x } return y }
+
+\`\`\`
+
+## Benchmark
+
+> 测试了一下2中方法基本上有10000倍的时间差距
+>
+> ![](https://github.com/kylesliu/awesome-golang-algorithm/blob/master/assets/images/0003-BenchMark.png)
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-leetcode](https://github.com/kylesliu/awesome-golang-algorithm)
+

docs/leetcode/1-100/0003.longest-substring-without-repeating-characters.md

@@ -0,0 +1,167 @@
+# 0004.Median-of-Two-Sorted-Arrays
+
+## Description
+
+There are two sorted arrays nums1 and nums2 of size m and n respectively.
+
+Find the median of the two sorted arrays. The overall run time complexity should be O\(log \(m+n\)\).
+
+You may assume nums1 and nums2 cannot be both empty.
+
+**Example 1:**
+
+```text
+nums1 = [1, 3]
+nums2 = [2]
+
+The median is 2.0
+```
+
+**Example 2:**
+
+```text
+nums1 = [1, 2]
+nums2 = [3, 4]
+
+The median is (2 + 3)/2 = 2.5
+```
+
+**Tags:** Math, String
+
+## 题意
+
+> 题意是在2个排序好的数组中寻找中位数
+
+## 题解
+
+### 思路1
+
+> 一种是根据规律构建儿茶搜索树
+
+```go
+// O(log(min(m, n))) Solution
+//
+solutions
+//
+// nums1: A1, A2, A3, ..., Am
+// nums2: B1, B2, B3, ..., Bn
+//
+// the key point is to find a i in [0, m] and a j in [0, n], which makes i + j = m + n + 1 / 2
+// so we get two sets of numbers as follow,
+// Left Part             |   Right Part
+// A1, A2, A3, ..., Ai   |   Ai+1, Ai+2, Ai+3, ..., Am
+// B1, B2, B3, ..., Bj   |   Bj+1, Bj+2, Bj+3, ..., Bn
+// if Ai <= Bj+1 and Bj <= Ai+1,
+// than we have two sets of numbers which any number in right part is greater than left part
+//
+// Left Part             |   Right Part
+//                       |   Ai+1, Ai+2, Ai+3, ..., Am
+// B1, B2, B3, ..., Bj   |   Bj+1, Bj+2, Bj+3, ..., Bn
+// if i == 0 means A is the right part, in that case, j + 1 will be out of range
+//
+// Left Part             |   Right Part
+// A1, A2, A3, ..., Ai   |
+// B1, B2, B3, ..., Bj   |   Bj+1, Bj+2, Bj+3, ..., Bn
+// if i == m means A is the left part, in that case, i + 1 will be out of range
+//
+// in that condition,
+// * if m + n is even
+//     the median is: max(Ai, Bj) + min(Ai+1, Bj+1) / 2
+// * if m + n is odd
+//     the median is: max(Ai, Bj)
+```
+
+```go
+package Solution
+
+func Min(a int, b int) int {
+    if a > b {
+        return b
+    }
+    return a
+}
+
+func Max(a int, b int) int {
+    if a > b {
+        return a
+    }
+    return b
+}
+
+func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
+    m, n := len(nums1), len(nums2)
+    halfLen := (m + n + 1) / 2
+
+    if m == 0 || n == 0 {
+        nums := append(nums1, nums2...)
+        if len(nums)%2 == 1 {
+            return float64(nums[halfLen-1])
+        } else {
+            return (float64(nums[halfLen-1]) + float64(nums[halfLen])) / 2.0
+        }
+    }
+
+    // make sure m < n, so j = halfLen - i is always greater than zero
+    var A, B []int
+    if m < n {
+        A, B = nums1, nums2
+    } else {
+        m, n = n, m
+        A, B = nums2, nums1
+    }
+
+    // find i in [0, m]
+    // especial, if i == 0 means A is the right part, if i == m means A is the left part
+    iMin, iMax := 0, m
+    for iMin <= iMax {
+        i := (iMin + iMax) / 2
+        j := halfLen - i
+
+        if i > 0 && j >= 0 && j < n && A[i-1] > B[j] {
+            // Ai > Bj+1, i need be smaller
+            iMax = i - 1
+        } else if j > 0 && i >= 0 && i < m && B[j-1] > A[i] {
+            // Bj > Ai+1, i need be greater
+            iMin = i + 1
+        } else {
+            var leftPartMax, rightPartMin float64
+            if i == 0 {
+                leftPartMax = float64(B[j-1])
+            } else if j == 0 {
+                leftPartMax = float64(A[i-1])
+            } else {
+                leftPartMax = float64(Max(A[i-1], B[j-1]))
+            }
+
+            if (m+n)%2 == 1 {
+                // m + n is odd
+                return leftPartMax
+            }
+
+            if i == m {
+                rightPartMin = float64(B[j])
+            } else if j == n {
+                rightPartMin = float64(A[i])
+            } else {
+                rightPartMin = float64(Min(A[i], B[j]))
+            }
+
+            // m + n is even
+            return (leftPartMax + rightPartMin) / 2.0
+        }
+    }
+
+    return -1.0
+}
+```
+
+### 思路2
+
+> 思路2 \`\`\`go
+
+\`\`\`
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-leetcode](https://github.com/kylesliu/awesome-golang-algorithm)
+