030

Author: DinghaoLI

016-反转链表/problem016.go

@@ -12,24 +12,14 @@ type NodeList struct {
 func reverse(head *NodeList) *NodeList {
 	if head == nil || head.Next == nil { return head }
 	vide := &NodeList{-1, nil}
-	// first
-	vide.Next = head
-	next := head.Next
-	head.Next = nil
-	head = next
-	next = next.Next
-	// rest
-	for next != nil {
+
+	for head != nil {
+		next := head.Next
 		head.Next = vide.Next
 		vide.Next = head
 		head = next
-		next = next.Next
 	}
 
-	// last one 
-	head.Next = vide.Next
-	vide.Next = head
-
 	return vide.Next
 
 }

029-数组中出现次数超过一半的数字/README.md

@@ -0,0 +1,31 @@
+# 题意
+
+题目描述
+
+输入一个字符串,按字典序打印出该字符串中字符的所有排列
+
+例如输入字符串abc,
+
+则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
+
+结果请按字母顺序输出。
+
+注意 输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母
+
+样例输入
+
+1 2 3 2 2 2 5 4 2
+
+样例输出
+
+2
+
+# 分析
+
+- 排序以后统计个数
+- 基于Partition函数的$O(n)$的查找第K大的数
+- 阵地攻守（特点-它出现的次数比其他所有的数组出现的次数之和还要多）pick
+- 使用map来建立数字到出现次数的映射
+
+
+

029-数组中出现次数超过一半的数字/problem029.go

@@ -0,0 +1,23 @@
+package problem010
+
+import "errors"
+
+func getMostFreq(nums []int) (int, error){
+	if len(nums) == 0 {
+		return -1, errors.New("Array is empty")
+	}
+	count := 1
+	value := nums[0]
+	for i := 1; i < len(nums); i++ {
+		if nums[i] == value {
+			count++
+		} else {
+			count--
+			if count == 0 {
+				value = nums[i]
+				count = 1
+			}
+		}
+	}
+	return value, nil
+}

029-数组中出现次数超过一半的数字/problem029_test.go

@@ -0,0 +1,41 @@
+package problem010
+
+import (
+    "testing"
+)
+
+func Test_case(t *testing.T) {
+   nums := []int{2,1,2,1,2}
+   res, err := getMostFreq(nums)
+   if res == 2 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+   nums = []int{1,2,2,2,2,6,7}
+   res, err = getMostFreq(nums)
+   if res == 2 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+   nums = []int{1}
+   res, err = getMostFreq(nums)
+   if res == 1 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+   nums = []int{}
+   res, err = getMostFreq(nums)
+   if err != nil {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+}
+

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

@@ -0,0 +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

@@ -0,0 +1,23 @@
+package problem010
+
+import "errors"
+
+func getMostFreq(nums []int) (int, error){
+	if len(nums) == 0 {
+		return -1, errors.New("Array is empty")
+	}
+	count := 1
+	value := nums[0]
+	for i := 1; i < len(nums); i++ {
+		if nums[i] == value {
+			count++
+		} else {
+			count--
+			if count == 0 {
+				value = nums[i]
+				count = 1
+			}
+		}
+	}
+	return value, nil
+}

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

@@ -0,0 +1,41 @@
+package problem010
+
+import (
+    "testing"
+)
+
+func Test_case(t *testing.T) {
+   nums := []int{2,1,2,1,2}
+   res, err := getMostFreq(nums)
+   if res == 2 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+   nums = []int{1,2,2,2,2,6,7}
+   res, err = getMostFreq(nums)
+   if res == 2 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+   nums = []int{1}
+   res, err = getMostFreq(nums)
+   if res == 1 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+   nums = []int{}
+   res, err = getMostFreq(nums)
+   if err != nil {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+}
+