035

Author: Dinghao LI

027-二叉搜索树与双向链表/problem027.go

@@ -4,32 +4,34 @@ import (
 	"fmt"
 )
 
+
+
 type TreeNode struct {
-	Val  int
-	Left *TreeNode
-	Right *TreeNode
+	Val int
+    Left *TreeNode
+    Right *TreeNode
 }
 
-func TreeToList(root *TreeNode) (*TreeNode, *TreeNode) {
+func TreeToList(root *TreeNode) (*TreeNode, *TreeNode){
 	head, tail := root, root
-	if root == nil { return head, tail }
-	if root.Left == nil && root.Right == nil {
-		head.Left, tail.Right = root, root
-		return head, tail
-	}
-	if root.Left != nil {
-		leftHead, leftTail := TreeToList(root.Left)
-		head = leftHead
-		root.Left = leftTail
-		leftTail.Right = root
-	} 
-	if root.Right != nil {
-		rightHead, rightTail := TreeToList(root.Right)
+    if root == nil { return head, tail }
+    if root.Left == nil && root.Right == nil {
+    	head.Left, tail.Right = root, root
+        return head, tail
+    }
+  	if root.Left != nil {
+    	leftHead, leftTail := TreeToList(root.Left)
+        head = leftHead
+        root.Left = leftTail
+        leftTail.Right = root  
+    }
+    if root.Right != nil {
+    	rightHead, rightTail := TreeToList(root.Right)
 		tail = rightTail
-		root.Right = rightHead
-		rightHead.Left = root
-	}
-	head.Left, tail.Right = head, tail
+        root.Right = rightHead
+        rightHead.Left = root
+    }
+    head.Left, tail.Right = head, tail
 	return head, tail
 }
 

030-最小的K个数/README.md

@@ -1,36 +1,36 @@
-#题意
+# 题意
 题目描述
 
 输入n个整数，找出其中最小的K个数。
 
 例如输入4,5,1,6,2,7,3,8这8个数字， 则最小的4个数字是1,2,3,4,。
 
-#分析
+# 分析
 
-##方法一--排序
+## 方法一--排序
 要求一个序列中最小的K个数，按照惯有的思维方式，很简单，先对这个序列从小到大排序，然后输出前面的最小的K个数即可；
 
 至于选取什么样的排序方法，第一时间应该想到的是快速排序，我们知道，快速排序平均时间复杂度为O(nlogn)，然后再遍历序列中前K个元素输出，即可，总的时间复杂度为O(nlogn + k) = O(nlogn)；——方法一
 
-##方法二--选择或者交换排序
+## 方法二--选择或者交换排序
 再进一步想想，题目并没有要求要查找的k个数，甚至是后面的n-k个数是有序的，既然这样，咱们又何必对所有的n个数都进行排序呢？ 这个时候，想到了选择或交换排序，即遍历n个数，先把最先遍历到的K个数存入大小为k的数组之中，对这k个数，利用选择或交换排序，找到k个数中的最大数Kmax(Kmax为这K个元素的数组中最大的元素)，用时间为O(k)（你应该知道，插入或选择排序查找操作需要O(k)的时间），后再继续遍历后n-k个数，x与Kmax比较：如果x< Kmax，则x代替Kmax，并再次重新找出K个元素的数组中的最大元素Kmax'；如果x>Kmax，则不更新数组。这样每次更新和不更新数组所用的时间为O(k)或O(0)，整趟下来，总的时间复杂度平均下来为：nO(k) = O(nk)；——方法二
 
-##方法三--最小堆
+## 方法三--最大堆
 当然，更好的办法是维护k个元素的最大堆，原理与上述第2个方案一致，即用容量为K的最大堆存储最先遍历的K个数，并假设它们即是最小的K个数，建堆需要O(k)后，有k1）。继续遍历数列，每次遍历一个元素x，与堆顶元素比较，x），否则不更新堆。这样下来，总费时O(k+(n-k)logk) = O(nlogk)。此方法得益于在堆中，查找等各项操作时间复杂度均为logk（不然，就如上述思路2所述：直接用数组也可以找出前k个小的元素，用时O(nk)）；
 
-##方法四--快速排序的分治划分（中位数作为枢轴）
+## 方法四--快速排序的分治划分（中位数作为枢轴）
 按编程之美第141页上解法二的所述，类似快速排序的划分方法，N个数存储在数组S中，再从数组中随机选取一个数X（随机选取枢纽元，可做到线性期望时间O(N)的复杂度），把数组划分为Sa和Sb两部分，Sa<= X <=Sb，如果要查找的K个小的元素小于Sa中的元素个数，则返回Sa中较小的K个元素，否则返回Sa中K个小的元素 + Sb中小的K-|Sa|个元素。像上述过程一样，这个运用类似快速排序的partition的快速选择Select算法寻找最小的K个元素，在最坏的情况下亦能做到O(N)的复杂度。
 
 不过值得一提的是，这个快速选择Select算法是选择数组中“中位数的中位数”作为枢纽元，而非随机选择枢纽元；
 
-##方法五--快速排序的分治划分（随机枢轴）
+## 方法五--快速排序的分治划分（随机枢轴）
 Randomized-Select，每次都是随机选择数列中的一个元素作为主元，在O(n)的时间内找到第K小的元素，然后遍历输出前面的K个小的元素。如果能的话，那么总的时间复杂度为线性期望时间：O(n+k) = O(n)（当n比较小时）；
 
-##方法六--线性排序
+## 方法六--线性排序
 线性时间的排序，即计数排序，时间复杂度虽能达到O(n)，但是，限制条件太多了，不常用；
 
-##方法七--最小堆与优先队列
+## 方法七--最小堆与优先队列
 ”可以用最小堆初始化数组，然后取这个优先队列前k个值。复杂度为O(n)+kO(logn)“。意思是针对整个数组序列建立最小堆，建堆所用时间为O(n)，然后取堆中的前k个数，即总的时间复杂度为：O(n+klogn)。
 
-##方法八--提取最小堆的元素
+## 方法八--提取最小堆的元素
 与上述思路7类似，不同的是在对元素数组原地建立最小堆O(n)后，然后提取K次，但是每次提取时，换到顶部的元素只需要下移顶多K次就足够了，下移次数逐次减少（而上述思路7每次提取都需要logn，所有提取K次，思路7需要K*logn，而本思路8只需要K^2）；

030-最小的K个数/problem030.go

@@ -1,23 +1,41 @@
-package problem010
+package main
 
-import "errors"
+import (
+	"fmt"
+	"errors"
+	. "../utils"
+)
 
-func getMostFreq(nums []int) (int, error){
-	if len(nums) == 0 {
-		return -1, errors.New("Array is empty")
+func getMostFreq(nums []int, k int) ([]int, error){
+	res := []int{}
+	if k > len(nums) {
+		return res, errors.New("k > length of nums")
 	}
-	count := 1
-	value := nums[0]
-	for i := 1; i < len(nums); i++ {
-		if nums[i] == value {
-			count++
+
+	maxHeap := NewMaxHeap()
+
+	for _, v := range nums {
+		if maxHeap.Length() < k {
+			maxHeap.Insert(v)
 		} else {
-			count--
-			if count == 0 {
-				value = nums[i]
-				count = 1
+			max, _ := maxHeap.Max()
+			if max > v {
+				maxHeap.DeleteMax()
+				maxHeap.Insert(v)
 			}
 		}
 	}
-	return value, nil
+	for maxHeap.Length()>0 {
+		v, _ := maxHeap.DeleteMax()
+		res = append(res, v)
+	}
+	return res, nil
+}
+
+func main() {
+	test := []int{1,2,3,4,5,6,7,8,9}
+	fmt.Println(test)
+	fmt.Println(getMostFreq(test, 3))
+	fmt.Println(getMostFreq(test, 4))
+	fmt.Println(getMostFreq(test, 5))
 }

030-最小的K个数/problem030_test.go

@@ -0,0 +1,23 @@
+# 题意
+
+题目描述
+
+HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。
+
+今天测试组开完会后,他又发话了:
+
+在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。
+
+但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？
+
+例如:{6,-3,-2,7,-15,1,2,2}, 连续子向量的最大和为8(从第0个开始,到第3个为止)。 你会不会被他忽悠住？
+
+
+# 分析见题目注释
+
+Leecode指路[LeetCode 53. Maximum Subarray
+](https://leetcode.com/problems/maximum-subarray/submissions/)
+
+
+
+

031-连续子数组的最大和/README.md

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"fmt"
+)
+
+// dp[i] 代表以i结尾时最大连续子数组的最大和
+// dp[i] 初始值为nums[0]
+// 计算dp[i]时
+// 如果dp[i-1]>0: 那我们放心的加进来所以dp[i] = nums[i]+dp[i-1]
+// 否则：dp[i]取自己 dp[i] = nums[i]
+// 再利用全局变量，保存出出现过的最大值
+func MaxSubset(nums []int) int {
+	if len(nums) == 0 { return 0 }
+	dp := make([]int, len(nums))
+	dp[0] = nums[0]
+	res := nums[0]
+	for i:=1; i<len(nums); i++{
+		if dp[i-1] > 0 {
+			dp[i] = nums[i]+dp[i-1]
+		} else {
+			dp[i] = nums[i]
+		}
+
+		if dp[i] > res {
+			res = dp[i]
+		}
+	}
+	return res
+}
+
+// 精简一些
+// dp[i] 代表以i结尾时最大连续子数组的最大和（同时）
+// 复制nums到dp
+// 如果dp[i-1]>0那就把dp[i]=dp[i-1]+dp[i]
+// 再利用全局变量，保存出出现过的最大值
+
+func MaxSubset2(nums []int) int {
+	if len(nums) == 0 { return 0 }
+	dp := make([]int, len(nums))
+	copy(dp, nums)
+	max := dp[0]
+	for i := 1; i < len(dp); i++ {
+		if dp[i-1]>0{
+			dp[i] = dp[i-1]+dp[i]
+		}
+		if dp[i]>max {
+			max = dp[i]
+		}
+	}
+	return max
+}
+
+func max(a,b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func main() {
+	test := []int{1,-2,3,10,-4,7,2,-5}
+	fmt.Println(test)
+	fmt.Println(MaxSubset(test))
+	fmt.Println(MaxSubset2(test))
+}

031-连续子数组的最大和/problem031.go

@@ -0,0 +1,53 @@
+# 题意
+
+题目描述
+
+从1到n整数中1出现的次数
+
+# 分治递归
+
+我们重新分析下这个问题，
+
+对于任意一个个位数n，只要n>=1,它就包含一个"1"；
+
+n<1，即n=0时，则包含的"1"的个数为0。
+
+于是我们考虑用分治的思想将任意一个n位数不断缩小规模分解成许多个个位数，这样求解就很方便。
+
+但是，我们该如何降低规模？
+
+仔细分析，我们会发现，
+
+**任意一个n位数中"1"的个位可以分解为两个n-1位数中"1"的个数的和，最后再加上一个与最高位数相关的常数C**
+例如，
+
+对于n=12，可以拆分为0109,1012，即 f(12) = f(10 - 1) + f(12 - 10) + 3,其中3是表示最高位为1的数字个数，这里就是10,11,12,
+对于n=132，可以拆分为099，100132，即f(132)=f(100 -1) + f(132 - 100) + 33，33代表最高位为1的数字的个数，这里就是100-132百位数字的1出新了33次.
+
+对于232，可以拆分为099，100232，即f(232) = 2\*f(100 - 1) + f(32) + 100，因为232大于199，所以它包括了所有最高位为1的数字即100-199，共100个。
+
+综上，我们分析得出，最后加的常数C只跟最高位n1是否为1有关
+
+当最高位为1时，常数C为原数字N去掉最高位后剩下的数字+1，如N=12时，$C = 2 + 1 = 3$，N=132时，$C = 32 + 1 = 33$
+
+当最高位大于1时，常数C为$10^(bit-1)$，其中bit为N的位数，如N=232时，bit=3，$C = 10^(bit-1) = 10^2 = 100$。 于是，我们可以列出递归方程如下：
+
+if(n1 == 1)
+    f(n) = f(10bit-1) + f(n - 10bit) + n - 10bit+ 1;
+else
+    f(n) = n1\*f(10bit-1) + f(n – n1\*10bit) + 10bit;
+进一步可以归结为
+
+f(n) = n1\*f(10bit-1) + f(n – n1\*10bit) + LEFT;
+其中
+if(n1 == 1)
+    LEFT = n - 10bit+ 1;
+else
+    LEFT = 10bit;
+
+此算法的优点是不用遍历1-N就可以得到f(N)。经过我测试，此算法的运算速度比解法一快了许多许多，数字在1010内时，算法都可以在毫秒级内结
+
+
+
+
+