1.1 排序

可以通过sort.Ints(arri)进行排序，其中arri就是需要被升序排序的数组或切片。
同理使用sort.Float64s(arri)进行float类型排序，同理strings类型也可以使用sort包进行排序
为了检查某个数组是否已经被排序，可以通过函数IntsAreSorted(a []int)bool 来检查，如果返回true则表示已经被排序。

  1. func main() {
  2.     intSort()
  3.     fmt.Println("------------------------------------------")
  4.     floatSort()
  5. }
  6. func intSort() {
  7.     a1 := [5]int{1, 2, 3, 4, 5}
  8.     a2 := []int{2, 1, 4, 5, 3}
  9.     fmt.Printf("a1类型是%v,是否已排序%t\n", reflect.TypeOf(a1), sort.IntsAreSorted(a1[:]))
  10.     fmt.Printf("a2类型是%v,是否已排序%t\n", reflect.TypeOf(a2), sort.IntsAreSorted(a2))
  11.     // 返回false表示未排序
  12.     if !sort.IntsAreSorted(a2) {
  13.         sort.Ints(a2)
  14.         fmt.Println("排序后的a2是：", a2)
  15.     }
  16. }
  18. func floatSort() {
  19.     a1 := [5]float64{1.1, 1.5, 1.6, 1.7, 1.8}
  20.     a2 := []float64{1.2, 3.4, 1.7, 3.2, 5.0}
  21.     fmt.Printf("a1类型是%s,是否已排序%t\n", reflect.TypeOf(a1), sort.Float64sAreSorted(a1[:]))
  22.     fmt.Printf("a2类型是%s,是否已排序%t\n", reflect.TypeOf(a2), sort.Float64sAreSorted(a2))
  23.     // 返回false表示未排序
  24.     if !sort.Float64sAreSorted(a2) {
  25.         sort.Float64s(a2)
  26.         fmt.Println("排序后的a2是：", a2)
  27.     }
  28. }
  30. /*
  31.     a1类型是[5]int,是否已排序true
  32.     a2类型是[]int,是否已排序false
  33.     排序后的a2是： [1 2 3 4 5]
  34.     ------------------------------------------
  35.     a1类型是[5]float64,是否已排序true
  36.     a2类型是[]float64,是否已排序false
  37.     排序后的a2是： [1.2 1.7 3.2 3.4 5]
  38. */

同样的也可以使用sort.String(strs []string)进行string的排序。

2.1 搜索

sort包中的搜索**采用的二分法，因此要搜索的数组必须是已经排序的**，否则索引无法正确查找到。

  2. func main() {
  3.     intSearch()
  4.     fmt.Println("---------------------")
  5.     floatSearch()
  6. }
  8. // ----------------------------------二分搜索(已经是被排序的数组)-------------------------------
  9. func intSearch() {
  10.     arr := []int{2, 1, 4, 5, 3}
  11.     sort.Ints(arr)
  12.     index := sort.SearchInts(arr, 4)
  13.     fmt.Println("排序后的结果是：",arr)
  14.     fmt.Println("4所在的索引是：", index)
  15. }
  17. func floatSearch() {
  18.     arr := []float64{1.2, 3.4, 1.7, 3.2, 5.0}
  19.     sort.Float64s(arr)
  20.     index := sort.SearchFloat64s(arr, 1.7)
  21.     fmt.Println("排序后的结果是：",arr)
  22.     fmt.Println("1.7所在的索引是：", index)
  23. }
  25. /*
  26.     排序后的结果是： [1 2 3 4 5]
  27.     4所在的索引是： 3
  28.     ---------------------
  29.     排序后的结果是： [1.2 1.7 3.2 3.4 5]
  30.     1.7所在的索引是： 1
  31. */

可以通过查看官方文档，获取更详细的信息 https://golang.org/pkg/sort/