sort包提供了对切片的排序和查找操作

常用函数

  • Float64s：对float64类型切片进行排序
  • Float64sAreSorted：判断float64类型切片是否有序
  • Ints： 对Int类型切片排序
  • IntsAreSorted： 判断Int类型切片是否有序
  • Strings： 对String类型切片排序
  • StringAreSorted：判断String类型切片是否有序
  • Slice：对切片通过自定义函数进行排序
  • SlicelsSorted:通过自定义函数切片是否有序
  • SliceStable：对切片通过自定义函数进行排序(相同元素保证原有顺序，稳定)
  • Search：在有序切片中通过自定义迭代范围，并通过自定义函数查找函数插入的位置
  • SearchFloat64s： 在有序的float64类型切片中查找元素插入的位置
  • SearchInts： 在有序的int类型切片中查找元素插入的位置
  • SearchStrings： 在有序的string类型切片中查找元素插入的位置

    实操

    learnSort.go

    ```go package learnSort

import ( “fmt” “sort” )

func LearnSort() { // 对int类型切片排序 nums := []int{3,2,10,5,8,19,2} sort.Ints(nums) fmt.Println(nums)

  1. // 查找int类型切片中元素插入的位置
  2. fmt.Println(sort.SearchInts(nums, 5))
  3. fmt.Println(sort.SearchInts(nums, 6))
  5. // 定义结构体切片
  6. users := []struct{
  7.     id int
  8.     name string
  9. }{
  10.     {3, "ligz"},
  11.     {2, "ligz2"},
  12.     {5, "ligz5"},
  13.     {10, "ligz10"},
  14. }
  15. fmt.Println(users)
  17. // 对结构体切片排序
  18. sort.Slice(users, func(i, j int) bool {
  19.     return users[i].id < users[j].id
  21. })
  22. fmt.Println(users)
  24. // 查找id 是否存在于切片中
  25. for _, value := range([]int{4,5}) {
  26.     idx := sort.Search(len(users), func(i int) bool {
  27.         return users[i].id >= value
  28.     })
  29.     if idx < len(users) && users[idx].id == value {
  30.         fmt.Printf("find %d index: %d\n", value, idx)
  31.     } else {
  32.         fmt.Printf("not found %d \n", value)
  33.     }
  34. }

}

  1. <a name="L1cSf"></a>
  2. ## learnSort_test.go
  3. ```go
  4. package learnSort
  6. import "testing"
  8. func TestLearnSort(t *testing.T) {
  9.     LearnSort()
  10. }

执行结果

  1. [2 2 3 5 8 10 19]
  2. 3
  3. 4
  4. [{3 ligz} {2 ligz2} {5 ligz5} {10 ligz10}]
  5. [{2 ligz2} {3 ligz} {5 ligz5} {10 ligz10}]
  6. not found 4 
  7. find 5 index: 2
  9. 进程 已完成，退出代码为 0