done 300

Author: xemxx

Diff for: common/heap/maxHeap.go

@@ -84,7 +84,7 @@ func shiftDown(arr []int, root, maxLen int) {
 // Create1 时间复杂度为O(NlogN).
 func Create1(arr []int) MaxHeap {
 	l := len(arr)
-	res := MaxHeap{make([]int, l)}
+	res := MaxHeap{make([]int, 0, l)}
 	for v := range arr {
 		res.Insert(v)
 	}

Diff for: common/main.go

@@ -2,12 +2,16 @@ package main
 
 import (
 	"fmt"
+	"leetcode/common/heap"
 	"leetcode/common/sort"
 )
 
 func main() {
 	a := []int{3, 44, 38, 5, 47, 15, 36, 26, 26, 27, 2, 46, 4, 19, 50, 48, 49}
-	fmt.Printf("QuickSort() = %v \n", sort.QuickSort(a, 0, len(a)-1))
-	fmt.Printf("MergeSort() = %v \n", sort.MergeSort(a, 0, len(a)-1))
-	fmt.Printf("HeapSort() = %v \n", sort.HeapSort(a))
+	fmt.Printf("QuickSort() = %v \n", sort.QuickSort(append([]int{}, a...), 0, len(a)-1))
+	fmt.Printf("MergeSort() = %v \n", sort.MergeSort(append([]int{}, a...), 0, len(a)-1))
+	fmt.Printf("MergeSort1() = %v \n", sort.MergeSort1(append([]int{}, a...)))
+	fmt.Printf("HeapSort() = %v \n", sort.HeapSort(append([]int{}, a...)))
+	fmt.Printf("MaxHeap.Create1() = %v \n", heap.Create1(append([]int{}, a...)))
+	fmt.Printf("Orange Arr = %v \n", a)
 }

Diff for: common/sort/mergeSort.go

@@ -13,9 +13,9 @@ func MergeSort(arr []int, low, hight int) []int {
 }
 
 func merge(arr []int, low, mid, hight int) {
-	a := make([]int, hight-low)
-	i, j := low, mid
-	for i < mid && j < hight {
+	a := make([]int, 0, hight-low)
+	i, j := low, mid+1
+	for i <= mid && j <= hight {
 		if arr[i] > arr[j] {
 			a = append(a, arr[j])
 			j++
@@ -24,35 +24,31 @@ func merge(arr []int, low, mid, hight int) {
 			i++
 		}
 	}
-	for i < mid {
+	for i <= mid {
 		a = append(a, arr[i])
 		i++
 	}
-	for j < hight {
+	for j <= hight {
 		a = append(a, arr[j])
 		j++
 	}
+	for k := range a {
+		arr[low+k] = a[k]
+	}
 }
 
 // MergeSort1 is another solution .
 // 该方法新建多个底层数组，空间浪费 .
 func MergeSort1(arr []int) []int {
 	l := len(arr)
-	if l > 2 {
+	if l >= 2 {
 		mid := l / 2
 		la := MergeSort1(arr[:mid])
 		ra := MergeSort1(arr[mid:])
 		a := merge1(la, ra)
 		return a
-	} else if l == 2 {
-		a := arr
-		if a[0] > a[1] {
-			a[0], a[1] = a[1], a[0]
-		}
-		return a
-	} else {
-		return []int{}
 	}
+	return arr
 }
 
 func merge1(la, ra []int) []int {

Diff for: done/2018 年力扣高频 算法面试题汇总/动态规划/128.最长连续序列/readme.md

@@ -19,7 +19,7 @@
 代码：
 ``` golang
 func longestConsecutive(nums []int) int {
-	mmp := make(map[int]bool, len(nums))
+	mmp := make(map[int]bool,len(nums))
 	for _, k := range nums {
 		mmp[k] = true
 	}

Diff for: done/2018 年力扣高频 算法面试题汇总/动态规划/300.最长上升子序列/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(lengthOfLIS([]int{3, 5, 6, 2, 5, 4, 19, 5, 6, 7, 12}))
+}

Diff for: done/2018 年力扣高频 算法面试题汇总/动态规划/300.最长上升子序列/readme.md

@@ -0,0 +1,68 @@
+## 动态规划
+核心思想：用一个数组`int arr[]`辅助，`arr[i]`代表到`i`为止的最长上升子序列的长度，然后由公式`arr[i]=max(arr[j])+1`得到`arr[i]`的值，前提是`j<i`
+具体实现：
+- 每次遍历`nums[i]`，开始遍历`arr[]`，选出最大的值然后再`+1`得到最后`arr[i]`的值即可。
+
+代码：
+``` golang
+func lengthOfLIS(nums []int) int {
+    if len(nums) == 0 {
+		return 0
+	}
+	max := 0
+	arr := make([]int, len(nums))
+	for i := range nums {
+		tmp := 0
+		for j := range arr {
+			if nums[j] < nums[i] {
+				if arr[j] > tmp {
+					tmp = arr[j]
+				}
+			}
+		}
+		arr[i] = tmp + 1
+		if arr[i] > max {
+			max = arr[i] + 1
+		}
+	}
+	return max
+}
+```
+
+时间复杂度为O(n^2)
+
+## 动归+二分
+原理([参考](https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-by-leetcode/))：他的方法依赖于这样一个事实，在给定数组中最长上升子序列可能达到 `i^th`，独立于后面在数组中出现的元素。因此，如果我们知道 `lis` 的长度不超过 `i^th`，我们可以根据索引为`j` 的元素包括 `(i+1)^th`元素来计算 `lis` 的长度，其中 `0≤j≤（i+1）`
+
+实现：新建数组`arr`，用于保存最长上升子序列，然后遍历`nums`，对于每个元素
+- 如果 `arr` 中元素都比它小，将它插到最后
+- 否则，用它覆盖掉比它大的元素中最小的那个，具体实现采用二分搜索
+总之就是让`arr`中存储比较小的元素。这样，`arr`未必是真实的最长上升子序列，但长度是对的
+
+代码:
+``` golang
+func lengthOfLIS(nums []int) int {
+	if len(nums) == 0 {
+		return 0
+	}
+	arr := make([]int, 0, len(nums))
+	arr = append(arr, nums[0])
+	for _, v := range nums[1:] {
+		if v > arr[len(arr)-1] {
+			arr = append(arr, v)
+		} else {
+			l, r := 0, len(arr)-1
+			for l < r {
+				mid := (l + r) / 2
+				if arr[mid] >= v {
+					r = mid
+				} else {
+					l = mid + 1
+				}
+			}
+			arr[l] = v
+		}
+	}
+	return len(arr)
+}
+```

Diff for: done/2018 年力扣高频 算法面试题汇总/动态规划/300.最长上升子序列/solution.go

@@ -0,0 +1,32 @@
+package main
+
+/*
+ * @lc app=leetcode.cn id=300 lang=golang
+ *
+ * [300] 最长上升子序列
+ */
+
+func lengthOfLIS(nums []int) int {
+	if len(nums) == 0 {
+		return 0
+	}
+	arr := make([]int, 0, len(nums))
+	arr = append(arr, nums[0])
+	for _, v := range nums[1:] {
+		if v > arr[len(arr)-1] {
+			arr = append(arr, v)
+		} else {
+			l, r := 0, len(arr)-1
+			for l < r {
+				mid := (l + r) / 2
+				if arr[mid] >= v {
+					r = mid
+				} else {
+					l = mid + 1
+				}
+			}
+			arr[l] = v
+		}
+	}
+	return len(arr)
+}