分片排序或搜索函数允许你以各种方式与分片进行交互和操作。Golang 的排序功能是核心的一部分。使用这个功能不需要安装，只需要导入 "sort "包。在排序函数的帮助下，你可以搜索任何一个重要的Golang排序函数列表如下。
Ints 函数 [升序]
Ints函数对一个整数片按升序排序。
语法
func Ints(intSlice []int)
例子
package main
import (
"fmt"
"sort"
)
func main() {
intSlice := []int{10, 5, 25, 351, 14, 9} // unsorted
fmt.Println("Slice of integer BEFORE sort:",intSlice)
sort.Ints(intSlice)
fmt.Println("Slice of integer AFTER sort:",intSlice)
}
输出
Slice of integer BEFORE sort: [10 5 25 351 14 9]
Slice of integer AFTER sort: [5 9 10 14 25 351]
Strings 函数 [升序排列]
Strings 函数按升序排列字符串片断，并按字母顺序排列。
语法
func Strings(strSlice []string)
例子
package main
import (
"fmt"
"sort"
)
func main() {
strSlice := []string{"Jamaica","Estonia","Indonesia","Hong Kong"} // unsorted
fmt.Println("Slice of string BEFORE sort:",strSlice)
sort.Strings(strSlice)
fmt.Println("Slice of string AFTER sort:",strSlice)
fmt.Println("\n-----------------------------------\n")
strSlice = []string{"JAMAICA","Estonia","indonesia","hong Kong"} // unsorted
fmt.Println("Slice of string BEFORE sort:",strSlice)
sort.Strings(strSlice)
fmt.Println("Slice of string AFTER sort:",strSlice)
}
输出
Slice of string BEFORE sort: [Jamaica Estonia Indonesia Hong Kong]
Slice of string AFTER sort: [Estonia Hong Kong Indonesia Jamaica]
-----------------------------------
Slice of string BEFORE sort: [JAMAICA Estonia indonesia hong Kong]
Slice of string AFTER sort: [Estonia JAMAICA hong Kong indonesia]
Float64s 函数 [升序排序］
Float64s 函数按升序对 float64 的一个片断进行排序。
语法
func Float64s(fltSlice []string)
例子
package main
import (
"fmt"
"sort"
)
func main() {
fltSlice := []float64{18787677.878716, 565435.321, 7888.545, 8787677.8716, 987654.252} // unsorted
fmt.Println("Slice BEFORE sort: ",fltSlice)
sort.Float64s(fltSlice)
fmt.Println("Slice AFTER sort: ",fltSlice)
}
输出
Slice BEFORE sort: [1.8787677878716e+07 565435.321 7888.545 8.7876778716e+06 987654.252]
Slice AFTER sort: [7888.545 565435.321 987654.252 8.7876778716e+06 1.8787677878716e+07]
IntsAreSorted函数
IntsAreSorted 函数测试一个整数片是否以升序排序。如果发现数字片以升序排序，则返回 true，否则返回 false。
语法
func IntsAreSorted(a []string) bool
例子
package main
import (
"fmt"
"sort"
)
func main() {
intSlice := []int{10, 5, 25, 351, 14, 9} // unsorted
fmt.Println(sort.IntsAreSorted(intSlice)) // false
intSlice = []int{5, 9, 14, 351, 614, 999} // sorted
fmt.Println(sort.IntsAreSorted(intSlice)) // true
}
输出
false
true
StringsAreSorted函数
StringsAreSorted 函数测试一个字符串片断是否以升序排序。如果发现字符串片断以升序排序，则返回 true，否则返回 false。
语法
func StringsAreSorted(strSlice []string) bool
例子
package main
import (
"fmt"
"sort"
)
func main() {
strSlice := []string{"Jamaica","Estonia","Indonesia","Hong Kong"} // unsorted
fmt.Println(sort.StringsAreSorted(strSlice)) // false
strSlice = []string{"JAMAICA","Estonia","indonesia","hong Kong"} // unsorted
fmt.Println(sort.StringsAreSorted(strSlice)) // false
strSlice = []string{"estonia","hong Kong","indonesia","jamaica"} // sorted
fmt.Println(sort.StringsAreSorted(strSlice)) // true
}
输出
false
false
true
Float64sAreSorted函数
Float64sAreSorted 函数测试一个浮点数64的片断是否以升序排序。如果发现float64的片断以升序排序，则返回true，否则返回false。
语法
func Float64sAreSorted(fltSlice []float64) bool
例子
package main
import (
"fmt"
"sort"
)
func main() {
fltSlice := []float64{18787677.878716, 565435.321, 7888.545, 8787677.8716, 987654.252} // unsorted
fmt.Println(sort.Float64sAreSorted(fltSlice)) // false
fltSlice = []float64{565435.321, 887888.545, 8787677.8716, 91187654.252} // sorted
fmt.Println(sort.Float64sAreSorted(fltSlice)) // true
}
输出
false
true
SearchInts函数 [升序排列]
SearchInts 函数搜索 x 在一个已排序的 int 片段中的位置，并返回 Search 指定的索引。这个函数只在片子是按排序顺序工作。如果在intSlice中找到x，那么它返回intSlice的索引位置，否则它返回x在排序片中的索引位置。下面的例子显示了SearchInts()函数的用法。
语法
func SearchInts(intSlice []int, x int) int
例子
package main
import (
"fmt"
"sort"
)
func main() {
// integer slice in unsort order
intSlice := []int{55, 22, 18, 9, 12, 82, 28, 36, 45, 65}
x := 18
pos := sort.SearchInts(intSlice,x)
fmt.Printf("Found %d at index %d in %v\n", x, pos, intSlice)
// slice need to be sort in ascending order before to use SearchInts
sort.Ints(intSlice) // slice sorted
pos = sort.SearchInts(intSlice,x)
fmt.Printf("Found %d at index %d in %v\n", x, pos, intSlice)
x = 54
pos = sort.SearchInts(intSlice,x)
fmt.Printf("Found %d at index %d in %v\n", x, pos, intSlice)
x = 99
pos = sort.SearchInts(intSlice,x)
fmt.Printf("Found %d at index %d in %v\n", x, pos, intSlice)
x = -5
pos = sort.SearchInts(intSlice,x)
fmt.Printf("Found %d at index %d in %v\n", x, pos, intSlice)
}
输出
Found 18 at index 0 in [55 22 18 9 12 82 28 36 45 65]
Found 18 at index 2 in [9 12 18 22 28 36 45 55 65 82]
Found 54 at index 7 in [9 12 18 22 28 36 45 55 65 82]
Found 99 at index 10 in [9 12 18 22 28 36 45 55 65 82]
Found -5 at index 0 in [9 12 18 22 28 36 45 55 65 82]
SearchStrings 函数 [升序排列]
SearchStrings函数搜索x在已排序的字符串片断中的位置，并返回Search指定的索引。该函数仅在切片按排序顺序工作。如果在strSlice中找到x，那么它返回strSlice的索引位置，否则它返回x在排序片中的索引位置。下面的例子显示了SearchStrings()函数的用法。
语法
func SearchStrings(strSlice []string, x string) int
例子
package main
import (
"fmt"
"sort"
)
func main() {
// string slice in unsorted order
strSlice := []string{"Texas","Washington","Montana","Alaska","Indiana","Ohio","Nevada"}
x := "Montana"
pos := sort.SearchStrings(strSlice,x)
fmt.Printf("Found %s at index %d in %v\n", x, pos, strSlice)
// slice need to be sort in ascending order before to use SearchStrings
sort.Strings(strSlice) // slice sorted
pos = sort.SearchStrings(strSlice,x)
fmt.Printf("Found %s at index %d in %v\n", x, pos, strSlice)
x = "Missouri"
pos = sort.SearchStrings(strSlice,x)
fmt.Printf("Found %s at index %d in %v\n", x, pos, strSlice)
x = "Utah"
pos = sort.SearchStrings(strSlice,x)
fmt.Printf("Found %s at index %d in %v\n", x, pos, strSlice)
x = "Ohio"
pos = sort.SearchStrings(strSlice,x)
fmt.Printf("Found %s at index %d in %v\n", x, pos, strSlice)
x = "OHIO"
pos = sort.SearchStrings(strSlice,x)
fmt.Printf("Found %s at index %d in %v\n", x, pos, strSlice)
x = "ohio"
pos = sort.SearchStrings(strSlice,x)
fmt.Printf("Found %s at index %d in %v\n", x, pos, strSlice)
}
输出
Found Montana at index 5 in [Texas Washington Montana Alaska Indiana Ohio Nevada]
Found Montana at index 2 in [Alaska Indiana Montana Nevada Ohio Texas Washington]
Found Missouri at index 2 in [Alaska Indiana Montana Nevada Ohio Texas Washington]
Found Utah at index 6 in [Alaska Indiana Montana Nevada Ohio Texas Washington]
Found Ohio at index 4 in [Alaska Indiana Montana Nevada Ohio Texas Washington]
Found OHIO at index 4 in [Alaska Indiana Montana Nevada Ohio Texas Washington]
Found ohio at index 7 in [Alaska Indiana Montana Nevada Ohio Texas Washington]
函数 SearchFloat64s [升序] 。
SearchFloat64s函数搜索x在float64的排序片中的位置，并返回Search指定的索引。这个函数只在一个片断是按排序顺序工作。如果在fltSlice中找到x，那么它返回fltSlice的索引位置，否则它返回x在排序片中的索引位置。下面的例子显示了SearchFloat64s()函数的用法。
语法
func SearchFloat64s(fltSlice []float64, x float64)
例子
package main
import (
"fmt"
"sort"
)
func main() {
// string slice in unsorted order
fltSlice := []float64{962.25, 514.251, 141.214, 96.142, 85.14}
x := 141.214
pos := sort.SearchFloat64s(fltSlice,x)
fmt.Printf("Found %f at index %d in %v\n", x, pos, fltSlice)
// slice need to be sort in ascending order before to use SearchFloat64s
sort.Float64s(fltSlice) // slice sorted
pos = sort.SearchFloat64s(fltSlice,x)
fmt.Printf("Found %f at index %d in %v\n", x, pos, fltSlice)
x = 8989.251
pos = sort.SearchFloat64s(fltSlice,x)
fmt.Printf("Found %f at index %d in %v\n", x, pos, fltSlice)
x = 10.251
pos = sort.SearchFloat64s(fltSlice,x)
fmt.Printf("Found %f at index %d in %v\n", x, pos, fltSlice)
x = 411.251
pos = sort.SearchFloat64s(fltSlice,x)
fmt.Printf("Found %f at index %d in %v\n", x, pos, fltSlice)
x = -411.251
pos = sort.SearchFloat64s(fltSlice,x)
fmt.Printf("Found %f at index %d in %v\n", x, pos, fltSlice)
}
输出
Found 141.214000 at index 0 in [962.25 514.251 141.214 96.142 85.14]
Found 141.214000 at index 2 in [85.14 96.142 141.214 514.251 962.25]
Found 8989.251000 at index 5 in [85.14 96.142 141.214 514.251 962.25]
Found 10.251000 at index 0 in [85.14 96.142 141.214 514.251 962.25]
Found 411.251000 at index 3 in [85.14 96.142 141.214 514.251 962.25]
Found -411.251000 at index 0 in [85.14 96.142 141.214 514.251 962.25]
搜索函数[升序和降序］
Search函数搜索x在字符串/浮点数/int的排序片中的位置，并返回Search所指定的索引。如果在数据中找到x，那么它返回数据的索引位置，否则它返回x在排序片中的索引位置。这个函数对升序和降序分片都有效，而上述3个搜索函数只对升序分片有效。下面的例子显示了Search()函数的用法。
输出
sort.Search(len(data), func(i int) bool { return data[i] >= x })
例子
package main
import (
"fmt"
"sort"
)
func main() {
fmt.Println("\n######## SearchInts not works in descending order ######## ")
intSlice := []int{55, 54, 53, 52, 51, 50, 48, 36, 15, 5} // sorted slice in descending
x := 36
pos := sort.SearchInts(intSlice,x)
fmt.Printf("Found %d at index %d in %v\n", x, pos, intSlice)
fmt.Println("\n######## Search works in descending order ########")
i := sort.Search(len(intSlice), func(i int) bool { return intSlice[i] <= x })
fmt.Printf("Found %d at index %d in %v\n", x, i, intSlice)
fmt.Println("\n\n######## SearchStrings not works in descending order ######## ")
// sorted slice in descending
strSlice := []string{"Washington","Texas","Ohio","Nevada","Montana","Indiana","Alaska"}
y := "Montana"
posstr := sort.SearchStrings(strSlice,y)
fmt.Printf("Found %s at index %d in %v\n", y, posstr, strSlice)
fmt.Println("\n######## Search works in descending order ########")
j := sort.Search(len(strSlice), func(j int) bool {return strSlice[j] <= y})
fmt.Printf("Found %s at index %d in %v\n", y, j, strSlice)
fmt.Println("\n######## Search works in ascending order ########")
fltSlice := []float64{10.10, 20.10, 30.15, 40.15, 58.95} // string slice in float64
z := 40.15
k := sort.Search(len(fltSlice), func(k int) bool {return fltSlice[k] >= z})
fmt.Printf("Found %f at index %d in %v\n", z, k, fltSlice)
}
输出
######## SearchInts not works in descending order ########
Found 36 at index 0 in [55 54 53 52 51 50 48 36 15 5]
######## Search works in descending order ########
Found 36 at index 7 in [55 54 53 52 51 50 48 36 15 5]
######## SearchStrings not works in descending order ########
Found Montana at index 0 in [Washington Texas Ohio Nevada Montana Indiana Alaska]
######## Search works in descending order ########
Found Montana at index 4 in [Washington Texas Ohio Nevada Montana Indiana Alaska]
######## Search works in ascending order ########
Found 40.150000 at index 3 in [10.1 20.1 30.15 40.15 58.95]
- Golang Sort函数
Sort函数以升序和降序对数据接口进行排序。它首先调用data.Len来确定n，然后以O(n*log(n))调用data.Less和data.Swap。下面的例子显示了Sort()函数的用法。
语法
func Sort(data Interface)
例子
package main
import (
"fmt"
"sort"
)
type Mobile struct {
Brand string
Price int
}
// ByPrice implements sort.Interface for []Mobile based on
// the Price field.
type ByPrice []Mobile
func (a ByPrice) Len() int { return len(a) }
func (a ByPrice) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByPrice) Less(i, j int) bool { return a[i].Price < a[j].Price }
// ByBrand implements sort.Interface for []Mobile based on
// the Brand field.
type ByBrand []Mobile
func (a ByBrand) Len() int { return len(a) }
func (a ByBrand) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByBrand) Less(i, j int) bool { return a[i].Brand > a[j].Brand }
func main() {
mobile := []Mobile{
{"Sony", 952},
{"Nokia", 468},
{"Apple", 1219},
{"Samsung", 1045},
}
fmt.Println("\n######## Before Sort #############\n")
for _, v := range mobile {
fmt.Println(v.Brand, v.Price)
}
fmt.Println("\n\n######## Sort By Price [ascending] ###########\n")
sort.Sort(ByPrice(mobile))
for _, v := range mobile {
fmt.Println(v.Brand, v.Price)
}
fmt.Println("\n\n######## Sort By Brand [descending] ###########\n")
sort.Sort(ByBrand(mobile))
for _, v := range mobile {
fmt.Println(v.Brand, v.Price)
}
}
输出
######## Before Sort #############
Sony 952
Nokia 468
Apple 1219
Samsung 1045
######## Sort By Price [ascending] ###########
Nokia 468
Sony 952
Samsung 1045
Apple 1219
######## Sort By Brand [descending] ###########
Sony 952
Samsung 1045
Nokia 468
Apple 1219
IsSorted函数
IsSorted函数通过返回true或false来报告数据是否被排序。下面的例子显示了IsSorted()函数的用法。
语法
func IsSorted(data Interface) bool
例子
package main
import (
"fmt"
"sort"
)
type Mobile struct {
Brand string
Price int
}
// ByPrice implements sort.Interface for []Mobile based on
// the Price field.
type ByPrice []Mobile
func (a ByPrice) Len() int { return len(a) }
func (a ByPrice) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByPrice) Less(i, j int) bool { return a[i].Price < a[j].Price }
func main() {
mobile1 := []Mobile{
{"Sony", 952},
{"Nokia", 468},
{"Apple", 1219},
{"Samsung", 1045},
}
fmt.Println("\nFound mobile1 price is sorted :", sort.IsSorted(ByPrice(mobile1))) // false
mobile2 := []Mobile{
{"Sony", 452},
{"Nokia", 768},
{"Apple", 919},
{"Samsung", 1045},
}
fmt.Println("\nFound mobile2 price is sorted :", sort.IsSorted(ByPrice(mobile2))) // true
}
输出
Found mobile1 price is sorted : false
Found mobile2 price is sorted : true
切片函数
这个Slice函数对所提供的slice进行排序，并给出所提供的less函数。如果提供的接口不是一个切片，该函数就会惊慌失措。下面的例子显示了Slice()函数的用法。
语法
func Slice(slice interface{}, less func(i, j int) bool)
例子
package main
import (
"fmt"
"sort"
)
func main() {
mobile := []struct {
Brand string
Price int
}{
{"Nokia", 700},
{"Samsung", 505},
{"Apple", 924},
{"Sony", 655},
}
sort.Slice(mobile, func(i, j int) bool { return mobile[i].Brand < mobile[j].Brand })
fmt.Println("\n\n######## Sort By Brand [ascending] ###########\n")
for _, v := range mobile {
fmt.Println(v.Brand, v.Price)
}
sort.Slice(mobile, func(i, j int) bool { return mobile[i].Brand > mobile[j].Brand })
fmt.Println("\n\n######## Sort By Brand [descending] ###########\n")
for _, v := range mobile {
fmt.Println(v.Brand, v.Price)
}
sort.Slice(mobile, func(i, j int) bool { return mobile[i].Price < mobile[j].Price })
fmt.Println("\n\n######## Sort By Price [ascending] ###########\n")
for _, v := range mobile {
fmt.Println(v.Brand, v.Price)
}
mobile = []struct {
Brand string
Price int
}{
{"MI", 900},
{"OPPO", 305},
{"iPhone", 924},
{"sony", 655},
}
sort.Slice(mobile, func(i, j int) bool { return mobile[i].Brand < mobile[j].Brand })
fmt.Println("\n\n######## Sort By Brand [ascending] ###########\n")
for _, v := range mobile {
fmt.Println(v.Brand, v.Price)
}
}
输出
######## Sort By Brand [ascending] ###########
Apple 924
Nokia 700
Samsung 505
Sony 655
######## Sort By Brand [descending] ###########
Sony 655
Samsung 505
Nokia 700
Apple 924
######## Sort By Price [ascending] ###########
Samsung 505
Sony 655
Nokia 700
Apple 924
######## Sort By Brand [ascending] ###########
MI 900
OPPO 305
iPhone 924
sony 655
SliceIsSorted函数
这个 SliceIsSorted 函数测试一个片断是否被排序。如果数据是被排序的，它将返回 "true "或 "false"。下面的例子显示了SliceIsSorted()函数的用法。
语法
func SliceIsSorted(slice interface{}, less func(i, j int) bool) bool
例子
package main
import (
"fmt"
"sort"
)
func main() {
mobile := []struct {
Brand string
Price int
}{
{"Nokia", 700},
{"Samsung", 505},
{"Apple", 924},
{"Sony", 655},
}
result := sort.SliceIsSorted(mobile, func(i, j int) bool { return mobile[i].Price < mobile[j].Price })
fmt.Println("Found price sorted:", result) // false
mobile = []struct {
Brand string
Price int
}{
{"Nokia", 700},
{"Samsung", 805},
{"Apple", 924},
{"Sony", 955},
}
result = sort.SliceIsSorted(mobile, func(i, j int) bool { return mobile[i].Price < mobile[j].Price })
fmt.Println("Found price sorted:", result) // true
mobile = []struct {
Brand string
Price int
}{
{"iPhone", 900},
{"MI", 805},
{"OPPO", 724},
{"Sony", 655},
}
result = sort.SliceIsSorted(mobile, func(i, j int) bool { return mobile[i].Brand < mobile[j].Brand })
fmt.Println("Found brand sorted:", result) // false
}
输出
Found price sorted: false
Found price sorted: true
Found brand sorted: false
IntSlice
IntSlice将Interface的方法附加到[]int上，以递增的顺序进行排序。Len 用来查找片断的长度。搜索返回对接收器和x应用SearchInts的结果。 下面的例子显示了IntSlice()函数的用法。
语法
type IntSlice []int
例子
package main
import (
"fmt"
"sort"
)
func main() {
s := []int{9, 22, 54, 33, -10, 40} // unsorted
sort.Sort(sort.IntSlice(s))
fmt.Println(s) // sorted
fmt.Println("Length of Slice: ", sort.IntSlice.Len(s)) // 6
fmt.Println("40 found in Slice at position: ", sort.IntSlice(s).Search(40)) // 4
fmt.Println("82 found in Slice at position: ", sort.IntSlice(s).Search(82)) // 6
fmt.Println("6 found in Slice at position: ", sort.IntSlice(s).Search(6)) // 0
}
输出
[-10 9 22 33 40 54]
Length of Slice: 6
40 found in Slice at position: 4
82 found in Slice at position: 6
6 found in Slice at position: 1
字符串切片
StringSlice将Interface的方法附加到[]string上，以递增的顺序进行排序。Len用于查找片断的长度。搜索返回对接收器和x应用SearchStrings的结果。排序用于对片断进行排序。下面的例子显示了StringSlice函数的用法。
语法
type StringSlice []string
例子
package main
import (
"fmt"
"sort"
)
func main() {
s := []string{"Washington","Texas","Ohio","Nevada","Montana","Indiana","Alaska"} // unsorted
sort.Sort(sort.StringSlice(s))
fmt.Println(s) // sorted
fmt.Println("Length of Slice: ", sort.StringSlice.Len(s)) // 7
fmt.Println("Texas found in Slice at position: ", sort.StringSlice(s).Search("Texas")) // 5
fmt.Println("Montana found in Slice at position: ", sort.StringSlice(s).Search("Montana")) // 2
fmt.Println("Utah found in Slice at position: ", sort.StringSlice(s).Search("Utah")) // 6
fmt.Println("OHIO found in Slice at position: ", sort.StringSlice(s).Search("OHIO")) // 4
fmt.Println("Ohio found in Slice at position: ", sort.StringSlice(s).Search("Ohio")) // 4
fmt.Println("ohio found in Slice at position: ", sort.StringSlice(s).Search("ohio")) // 7
}
输出
[Alaska Indiana Montana Nevada Ohio Texas Washington]
Length of Slice: 7
Texas found in Slice at position: 5
Montana found in Slice at position: 2
Utah found in Slice at position: 6
OHIO found in Slice at position: 4
Ohio found in Slice at position: 4
ohio found in Slice at position: 7
Float64Slice
Float64Slice将Interface的方法附加到[]float64上，按照递增的顺序进行排序。Len用于查找slice的长度。搜索返回对接收器和x应用SearchFloat64的结果。排序用于对切片进行排序。下面的例子显示了 Float64Slice 函数的用法。
语法
type Float64Slice []float64
例子
package main
import (
"fmt"
"sort"
)
func main() {
s := []float64{85.201, 14.74, 965.25, 125.32, 63.14} // unsorted
sort.Sort(sort.Float64Slice(s))
fmt.Println(s) // sorted
fmt.Println("Length of Slice: ", sort.Float64Slice.Len(s)) // 5
fmt.Println("123.32 found in Slice at position: ", sort.Float64Slice(s).Search(125.32)) // 3
fmt.Println("999.15 found in Slice at position: ", sort.Float64Slice(s).Search(999.15)) // 5
fmt.Println("12.14 found in Slice at position: ", sort.Float64Slice(s).Search(12.14)) // 0
}
输出
[14.74 63.14 85.201 125.32 965.25]
Length of Slice: 5
123.32 found in Slice at position: 3
999.15 found in Slice at position: 5
12.14 found in Slice at position: 0
反转函数 [降序]
Reverse 函数按相反的顺序返回一个片断。下面的例子显示了Reverse()函数的用法。
语法
func Reverse(data Interface) Interface
例子
package main
import (
"fmt"
"sort"
)
func main() {
a := []int{15, 4, 33, 52, 551, 90, 8, 16, 15, 105} // unsorted
sort.Sort(sort.Reverse(sort.IntSlice(a)))
fmt.Println("\n",a)
a = []int{-15, -4, -33, -52, -551, -90, -8, -16, -15, -105} // unsorted
sort.Sort(sort.Reverse(sort.IntSlice(a)))
fmt.Println("\n",a)
b := []string{"Montana","Alaska","Indiana","Nevada","Washington","Ohio","Texas"} // unsorted
sort.Sort(sort.Reverse(sort.StringSlice(b)))
fmt.Println("\n",b)
b = []string{"ALASKA","indiana","OHIO","Nevada","Washington","TEXAS","Montana"} // unsorted
sort.Sort(sort.Reverse(sort.StringSlice(b)))
fmt.Println("\n",b)
c := []float64{90.10, 80.10, 160.15, 40.15, 8.95} // unsorted
sort.Sort(sort.Reverse(sort.Float64Slice(c)))
fmt.Println("\n",c)
c = []float64{-90.10, -80.10, -160.15, -40.15, -8.95} // unsorted
sort.Sort(sort.Reverse(sort.Float64Slice(c)))
fmt.Println("\n",c)
}
输出
[551 105 90 52 33 16 15 15 8 4]
[-4 -8 -15 -15 -16 -33 -52 -90 -105 -551]
[Washington Texas Ohio Nevada Montana Indiana Alaska]
[indiana Washington TEXAS OHIO Nevada Montana ALASKA]
[160.15 90.1 80.1 40.15 8.95]
[-8.95 -40.15 -80.1 -90.1 -160.15]
