Merge pull request #67 from the-origin/master

 add sort for []interface

Author: polaris1119

chapter03/03.1.md

@@ -42,7 +42,7 @@ Sort() 方法惟一的参数就是待排序的数据集合。
 
 下面是一个使用 sort 包对学生成绩排序的示例：
 
-```golang
+```go
 package main
 
 import (
@@ -101,7 +101,7 @@ func main() {
          [{leao 90} {hikerell 91} {alan 95} {acmfly 96}]
 
 该示例实现的是升序排序，如果要得到降序排序结果，其实只要修改 Less() 函数：
-```golang
+```go
 //Less(): 成绩降序排序 , 只将小于号修改为大于号
 func (s StuScores) Less(i, j int) bool {
 	return s[i].score > s[j].score
@@ -112,7 +112,7 @@ func (s StuScores) Less(i, j int) bool {
     func Reverse(data Interface) Interface
 
 我们可以看到 Reverse() 返回的一个 sort.Interface 接口类型，整个 Reverse() 的内部实现比较有趣：
-```golang
+```go
     // 定义了一个 reverse 结构类型，嵌入 Interface 接口
     type reverse struct {
         Interface
@@ -130,7 +130,7 @@ func (s StuScores) Less(i, j int) bool {
     }
 ```
 了解内部原理后，可以在学生成绩排序示例中使用 Reverse() 来实现成绩升序排序：
-```golang
+```go
     sort.Sort(sort.Reverse(stus))
     fmt.Println(stus)
 ```
@@ -145,7 +145,7 @@ func (s StuScores) Less(i, j int) bool {
 
 Search() 函数一个常用的使用方式是搜索元素 x 是否在已经升序排好的切片 s 中：
 
-```golang
+```go
     x := 11
     s := []int{3, 6, 8, 11, 45} // 注意已经升序排序
     pos := sort.Search(len(s), func(i int) bool { return s[i] >= x })
@@ -158,7 +158,7 @@ Search() 函数一个常用的使用方式是搜索元素 x 是否在已经升
 
 官方文档还给出了一个猜数字的小程序：
 
-```golang
+```go
 func GuessingGame() {
 	var s string
 	fmt.Printf("Pick an integer from 0 to 100.\n")
@@ -181,7 +181,7 @@ func GuessingGame() {
 
 *sort*包定义了一个 IntSlice 类型，并且实现了 sort.Interface 接口：
 
-```golang
+```go
     type IntSlice []int
     func (p IntSlice) Len() int           { return len(p) }
     func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
@@ -192,34 +192,34 @@ func GuessingGame() {
     func (p IntSlice) Search(x int) int { return SearchInts(p, x) }
 ```
 并且提供的 sort.Ints() 方法使用了该 IntSlice 类型：
-```goalng
+```go
     func Ints(a []int) { Sort(IntSlice(a)) }
 ```
 
 所以，对[]int 切片排序更常使用 sort.Ints()，而不是直接使用 IntSlice 类型：
 
-```golang
+```go
     s := []int{5, 2, 6, 3, 1, 4} // 未排序的切片数据
     sort.Ints(s)
     fmt.Println(s) // 将会输出[1 2 3 4 5 6]
 ```
 如果要使用降序排序，显然要用前面提到的 Reverse() 方法：
 
-```golang
+```go
     s := []int{5, 2, 6, 3, 1, 4} // 未排序的切片数据
     sort.Sort(sort.Reverse(sort.IntSlice(s)))
     fmt.Println(s) // 将会输出[6 5 4 3 2 1]
 ```
 
 如果要查找整数 x 在切片 a 中的位置，相对于前面提到的 Search() 方法，*sort*包提供了 SearchInts():
 
-```golang
+```go
     func SearchInts(a []int, x int) int
 ```
 注意，SearchInts() 的使用条件为：**切片 a 已经升序排序**
 以下是一个错误使用的例子：
 
-```golang
+```go
     s := []int{5, 2, 6, 3, 1, 4} // 未排序的切片数据
     fmt.Println(sort.SearchInts(s, 2)) // 将会输出 0 而不是 1
 ```
@@ -228,7 +228,7 @@ func GuessingGame() {
 
 实现与 Ints 类似，只看一下其内部实现：
 
-```golang
+```go
     type Float64Slice []float64
 
     func (p Float64Slice) Len() int           { return len(p) }
@@ -239,9 +239,11 @@ func GuessingGame() {
 ```
 与 Sort()、IsSorted()、Search() 相对应的三个方法：  
 
+```go
     func Float64s(a []float64)  
     func Float64sAreSorted(a []float64) bool
     func SearchFloat64s(a []float64, x float64) int
+```
 
 要说明一下的是，在上面 Float64Slice 类型定义的 Less 方法中，有一个内部函数 isNaN()。 
 isNaN() 与*math*包中 IsNaN() 实现完全相同，*sort*包之所以不使用 math.IsNaN()，完全是基于包依赖性的考虑，应当看到，*sort*包的实现不依赖与其他任何包。
@@ -252,7 +254,7 @@ isNaN() 与*math*包中 IsNaN() 实现完全相同，*sort*包之所以不使用
 
 实现与 Ints 类似，只看一下其内部实现：
 
-```golang
+```go
     type StringSlice []string
 
     func (p StringSlice) Len() int           { return len(p) }
@@ -268,6 +270,178 @@ isNaN() 与*math*包中 IsNaN() 实现完全相同，*sort*包之所以不使用
     func StringsAreSorted(a []string) bool
     func SearchStrings(a []string, x string) int
 
+## 3.1.3 []interface 排序与查找
+
+通过前面的内容我们可以知道，只要实现了 `sort.Interface` 接口，即可通过 sort 包内的函数完成排序，查找等操作。并且 sort 包已经帮我们把`[]int`,`[]float64`,`[]string` 三种类型都实现了该接口，我们可以方便的调用。但是这种用法对于其它数据类型的 slice 不友好，可能我们需要为大量的 struct 定义一个单独的 []struct 类型，再为其实现 `sort.Interface` 接口，类似这样：
+```go
+    type Person struct {
+        Name string
+        Age  int
+    }
+    type Persons []Person
+    
+    func (p Persons) Len() int {
+        panic("implement me")
+    }
+    
+    func (p Persons) Less(i, j int) bool {
+        panic("implement me")
+    }
+    
+    func (p Persons) Swap(i, j int) {
+        panic("implement me")
+    }
+```
+
+> 思考一个问题：为什么 sort 包可以完成 `[]int` 的排序，而不能完成 `[]struct` 的排序？
+
+因为排序涉及到比较两个变量的值，而 struct 可能包含多个属性，程序并不知道你想以哪一个属性或哪几个属性作为衡量大小的标准。如果你能帮助程序完成比较，并将结果返回， sort 包内的方法就可以完成排序，判断，查找等。sort 包提供了以下函数：
+
+```go
+    func Slice(slice interface{}, less func(i, j int) bool) 
+    func SliceStable(slice interface{}, less func(i, j int) bool) 
+    func SliceIsSorted(slice interface{}, less func(i, j int) bool) bool 
+    func Search(n int, f func(int) bool) int
+```
+
+
+通过函数签名可以看到，排序相关的三个函数都接收 `[]interface`，并且需要传入一个比较函数，用于为程序比较两个变量的大小，因为函数签名和作用域的原因，这个函数只能是 `匿名函数`。
+
+**1. sort.Slice**
+
+该函数完成 []interface 的排序，举个栗子：
+```go
+	people := []struct {
+		Name string
+		Age  int
+	}{
+		{"Gopher", 7},
+		{"Alice", 55},
+		{"Vera", 24},
+		{"Bob", 75},
+	}
+
+	sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age }) // 按年龄升序排序
+	fmt.Println("Sort by age:", people)
+	
+	// Output:
+	/ /By age: [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]
+```
+
+
+**2. sort.SliceStable**
+
+该函数完成 []interface 的稳定排序，举个栗子：
+```go
+	people := []struct {
+		Name string
+		Age  int
+	}{
+		{"Gopher", 7},
+		{"Alice", 55},
+		{"Vera", 24},
+		{"Bob", 75},
+	}
+
+	sort.Slice(people, func(i, j int) bool { return people[i].Age > people[j].Age }) // 按年龄降序排序
+	fmt.Println("Sort by age:", people)
+	
+	// Output:
+	// By age: [{Bob 75} {Alice 55} {Vera 24} {Gopher 7}]
+```
+
+**3. sort.SliceIsSorted**
+
+该函数判断 []interface 是否为有序，举个栗子：
+```go
+    people := []struct {
+        Name string
+        Age  int
+    }{
+        {"Gopher", 7},
+        {"Alice", 55},
+        {"Vera", 24},
+        {"Bob", 75},
+    }
+    
+    sort.Slice(people, func(i, j int) bool { return people[i].Age > people[j].Age }) // 按年龄降序排序
+    fmt.Println("Sort by age:", people)
+    
+    fmt.Println("Sorted:",sort.SliceIsSorted(people,func(i, j int) bool { return people[i].Age < people[j].Age }))
+    // Output:
+    // Sort by age: [{Bob 75} {Alice 55} {Vera 24} {Gopher 7}]
+    // Sorted: false
+```
+
+> sort 包没有为 []interface 提供反序函数，但是从 1 和 2 可以看出，我们传入的比较函数已经决定了排序结果是升序还是降序。
+
+> 判断 slice 是否为有序，同样取决于我们传入的比较函数，从 3 可以看出，虽然 slice 已经按年龄降序排序，但我们在判断 slice 是否为有序时给的比较函数是判断其是否为升序有序，所以最终得到的结果为 false。
+
+
+**4. sort.Search**
+
+该函数判断 []interface 是否存在指定元素，举个栗子：
+
+- 升序 slice
+
+> sort 包为 `[]int`,`[]float64`,`[]string` 提供的 Search 函数其实也是调用的该函数，因为该函数是使用的二分查找法，所以要求 slice 为升序排序状态。并且判断条件必须为 `>=`，这也是官方库提供的三个查找相关函数的的写法。
+
+```go
+	a := []int{2, 3, 4, 200, 100, 21, 234, 56}
+	x := 21
+	
+	sort.Slice(a, func(i, j int) bool { return a[i] < a[j] })   // 升序排序
+	index := sort.Search(len(a), func(i int) bool { return a[i] >= x }) // 查找元素
+	
+	if index < len(a) && a[index] == x {
+		fmt.Printf("found %d at index %d in %v\n", x, index, a)
+	} else {
+		fmt.Printf("%d not found in %v,index:%d\n", x, a, index)
+	}
+    
+    // Output:
+    // found 21 at index 3 in [2 3 4 21 56 100 200 234]
+```
+
+- 降序 slice
+
+ 如果 slice 是降序状态，而我们又不想将其变为升序，只需将判断条件由 `>=` 变更为 `<=` 即可。此处就不给代码了，有兴趣的同学可以自己去尝试一下。推荐采用升序排列及相应的判断条件，与官方函数保持风格一致。
+ 
+ **5. 性能测试**
+
+```
+$ go test -bench=.
+goos: windows
+goarch: amd64
+pkg: lib/m_sort
+BenchmarkSortIntByInterfaceStable-12               30000             42365 ns/op
+BenchmarkSortIntByInterface-12                      3000            409606 ns/op
+BenchmarkSortIntByFunctionStable-12                50000             38955 ns/op
+BenchmarkSortIntByFunction-12                   50000000                35.0 ns/op
+BenchmarkSortFloatByInterfaceStable-12             20000             62481 ns/op
+BenchmarkSortFloatByInterface-12                    3000            432123 ns/op
+BenchmarkSortFloatByFunctionStable-12              30000             40968 ns/op
+BenchmarkSortFloatByFunction-12                 50000000                35.1 ns/op
+BenchmarkSortStringByInterfaceStable-12            20000             76405 ns/op
+BenchmarkSortStringByInterface-12                   3000            570894 ns/op
+BenchmarkSortStringByFunctionStable-12             20000             72865 ns/op
+BenchmarkSortStringByFunction-12                50000000                39.5 ns/op
+BenchmarkSortPersonByInterfaceStable-12            30000             43716 ns/op
+BenchmarkSortPersonByInterface-12                   3000            425633 ns/op
+BenchmarkSortPersonByFunctionStable-12             30000             40954 ns/op
+BenchmarkSortPersonByFunction-12                50000000                36.2 ns/op
+PASS
+ok      lib/m_sort      28.921s
+```
+
+- 测试分为 int、float64、string、struct 四种数据类型。每种数据类型进行 实现接口的稳定排序、实现接口的排序、调用函数的稳定排序、调用函数的排序 四种方式。
+
+- 测试 slice 长度为 10000 的情况下，调用函数的排序与实现接口的排序差距最大，性能普遍差距在 10000 倍以上。
+
+- 两种稳定排序性能差别不大，调用函数的稳定排序比实现接口的稳定排序稍快。
+
+- 推荐使用直接调用函数的方式进行排序（sort.SliceSort、sort.SliceSortStable），并且这些函数接受参数类型为 []interface{} ，这意味着任意数据类型都可以调用该方法，只需传入一个比较函数即可，无需实现接口。
+
 # 导航 #
 
 - [第三章 数据结构与算法](/chapter03/03.0.md)