最受欢迎的Golang切片排序,反向搜索功能

切片排序或搜索功能允许您以各种方式与切片进行交互并进行操作。 高朗排序功能是核心部分。使用此功能不需要安装,只需导入“ sort”包即可。借助sort函数,您可以搜索任意一个重要的Golang排序函数列表如下:

1)高朗 整数 功能[升序]

整数函数按升序对整数切片进行排序。

句法:
func 整数(intSlice []int)
例:
package main

import (
	"fmt"
	"sort"
)

func main() {
	intSlice := []int{10, 5, 25, 351, 14, 9} // unsorted
	fmt.Println("片 of integer BEFORE sort:",intSlice)	
	sort.Ints(intSlice)
	fmt.Println("片 of integer AFTER  sort:",intSlice)	
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go 整数切片之前排序:[10 5 25 351 14 9] 整数AFTER排序后的切片:[5 9 10 14 25 351] C:\golang>

2)高朗 弦乐 功能[升序]

弦乐函数按字典顺序升序对字符串的一部分进行排序。

句法:
func 弦乐(strSlice []string)
例:
package main

import (
	"fmt"
	"sort"
)

func main() {
	strSlice := []string{"Jamaica","Estonia","Indonesia","Hong Kong"} // unsorted
	fmt.Println("片 of string BEFORE sort:",strSlice)	
	sort.Strings(strSlice)
	fmt.Println("片 of string AFTER  sort:",strSlice)

	fmt.Println("\n-----------------------------------\n")

	strSlice = []string{"JAMAICA","Estonia","indonesia","hong Kong"} // unsorted
	fmt.Println("片 of string BEFORE sort:",strSlice)	
	sort.Strings(strSlice)
	fmt.Println("片 of string AFTER  sort:",strSlice)
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go 排序之前的一串字符串:[牙买加爱沙尼亚印度尼西亚香港] 片后的字符串排序:[爱沙尼亚香港印度尼西亚牙买加] ----------------------------------- 在排序之前先切一串字符串:[牙买加爱沙尼亚印度尼西亚香港] 片后的字符串分类:[爱沙尼亚牙买加香港印度尼西亚] C:\golang>

3)高朗 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("片 BEFORE sort: ",fltSlice)
	
	sort.Float64s(fltSlice)
	
	fmt.Println("片 AFTER sort: ",fltSlice)
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go 在排序之前先切片:[1.8787677878716e + 07 565435.321 7888.545 8.7876778716e + 06 987654.252] 切片后排序:[7888.545 565435.321 987654.252 8.7876778716e + 06 1.8787677878716e + 07] C:\golang>

4)高朗 积分排序 功能

积分排序函数测试整数切片是否按升序排序。如果按升序找到数字片,则返回true,否则返回false。

句法:
func 积分排序(a []string) bool
例:
package main
 
import (
    "fmt"
    "sort"
)
 
func main() {
    intSlice := []int{10, 5, 25, 351, 14, 9}	// unsorted
	fmt.Println(sort.IntsAreSorted(intSlice))	// 假
	
	intSlice = []int{5, 9, 14, 351, 614, 999}	// sorted
	fmt.Println(sort.IntsAreSorted(intSlice))	// 真正
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go false true C:\golang>

5)高朗 弦乐AreSorted 功能

弦乐AreSorted函数测试字符串的切片是否按升序排序。如果按升序找到字符串切片,则返回true,否则返回false。

句法:
func 弦乐AreSorted(strSlice []string) bool
例:
package main
 
import (
    "fmt"
    "sort"
)
 
func main() {
    strSlice := []string{"Jamaica","Estonia","Indonesia","Hong Kong"} // unsorted
    fmt.Println(sort.StringsAreSorted(strSlice))	// 假
	
    strSlice = []string{"JAMAICA","Estonia","indonesia","hong Kong"} // unsorted
    fmt.Println(sort.StringsAreSorted(strSlice))	// 假
	
	strSlice = []string{"estonia","hong Kong","indonesia","jamaica"} // sorted
    fmt.Println(sort.StringsAreSorted(strSlice))	// 真正
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go false false true C:\golang>

6)高朗 Float64sAreSorted 功能

Float64sAreSorted函数测试是否对float64s的一部分按升序排序。如果以升序找到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))	// 假
	
	fltSlice = []float64{565435.321, 887888.545, 8787677.8716, 91187654.252} // sorted
	fmt.Println(sort.Float64sAreSorted(fltSlice))	// 真正
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go false true C:\golang>

7)高朗 搜索Ints 功能[升序]

搜索Ints函数在排序的int切片中搜索x的位置,并返回Search指定的索引。如果slice仅按排序顺序,则此功能有效。如果在intSlice中找到x,则返回intSlice的索引位置,否则返回x符合排序后的切片的索引位置。以下示例显示SearchInts()函数的用法:

句法:
func 搜索Ints(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 搜索Ints
	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)
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go 在[55 22 18 9 12 82 28 36 45 65]的索引0中找到18 在[9 12 18 22 28 36 45 55 65 82]的索引2中找到18 在[9 12 18 22 28 36 45 55 65 82]的索引7中发现54 在[9 12 18 22 28 36 45 55 65 82]的索引10中发现99 在[9 12 18 22 28 36 45 55 65 82]的索引0中找到-5 C:\golang>

8)高朗 搜索字符串 功能[升序]

搜索字符串函数在已排序的字符串切片中搜索x的位置,并返回Search指定的索引。如果slice仅按排序顺序,则此功能有效。如果在strSlice中找到x,则它返回strSlice的索引位置,否则返回x符合已排序切片的索引位置。下面的示例显示SearchStrings()函数的用法:

句法:
func 搜索字符串(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 搜索字符串
	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)
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go 在[德州华盛顿蒙大拿州阿拉斯加印第安纳州俄亥俄州内华达州]的索引5中找到蒙大拿州 在[阿拉斯加印第安纳州内华达州蒙大拿州内华达州俄亥俄州德克萨斯州华盛顿]索引2中找到了蒙大拿州 在[阿拉斯加印第安纳州内华达州蒙大拿州内华达州俄亥俄州德克萨斯州华盛顿]的索引2中找到密苏里州 在[阿拉斯加印第安纳州内华达州蒙大拿州内华达州俄亥俄州德克萨斯州华盛顿]索引6中找到犹他州 在[阿拉斯加印第安纳州内华达州蒙大拿州内华达州俄亥俄州德克萨斯州华盛顿]索引4中找到俄亥俄州。 在[阿拉斯加印第安纳州内华达州蒙大拿州内华达州俄亥俄州德克萨斯州华盛顿]的索引4中找到OHIO 在[阿拉斯加印第安纳州内华达州蒙大拿州内华达州俄亥俄州德克萨斯州华盛顿]的索引7中找到俄亥俄州 C:\golang>

9)高朗 搜索Float64s 功能[升序]

搜索Float64s函数在float64的排序切片中搜索x的位置,并返回Search指定的索引。如果切片仅按排序顺序,则此功能有效。如果在fltSlice中找到x,则它将返回fltSlice的索引位置,否则将返回x符合已排序切片的索引位置。下面的示例显示SearchFloat64s()函数的用法:

句法:
func 搜索Float64s(fltSlice []float64, x float64) int
例:
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 搜索Float64s
	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)
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go 在[962.25 514.251 141.214 96.142 85.14]的索引0中找到141.214000 在[85.14 96.142 141.214 514.251 962.25]的索引2中找到141.214000 在[85.14 96.142 141.214 514.251 962.25]的索引5中找到8989.251000 在[85.14 96.142 141.214 514.251 962.25]的索引0中找到10.251000 在[85.14 96.142 141.214 514.251 962.25]的索引3中找到411.251000 在[85.14 96.142 141.214 514.251 962.25]的索引0中找到-411.251000 C:\golang>

10)高朗 搜索 功能[升序和降序]

搜索函数在字符串/浮点数/整数的排序切片中搜索x的位置,并返回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######## 搜索Ints不适用于降序######## ")    
	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########搜索按降序工作########")	
	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######## 搜索字符串降序不起作用######## ")		
	// 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########搜索按降序工作########")
	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########搜索按升序工作########")		
    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)	
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go ######## 搜索Ints不适用于降序######## 在[55 54 53 52 51 50 48 36 15 5]的索引0中找到36 ########搜索按降序工作######## 在[55 54 53 52 51 50 48 36 15 5]的索引7中找到36 ######## 搜索字符串降序不起作用######## 在[华盛顿德克萨斯州俄亥俄州内华达州蒙大拿州印第安纳州阿拉斯加]的索引0中找到蒙大拿州 ########搜索按降序工作######## 在[华盛顿德克萨斯州俄亥俄州内华达州蒙大拿州印第安纳州阿拉斯加]的索引4中找到蒙大拿州 ########搜索按升序工作######## 在[10.1 20.1 30.15 40.15 58.95]的索引3中找到40.150000 C:\golang>

11)高朗 分类 功能

分类函数以升序和降序对数据接口进行排序。它首先对data.Len进行调用以确定n,然后对data.Less和data.Swap进行O(n * log(n))调用。下面的示例显示Sort()函数的用法:

句法:
func 分类(data 接口)
例:
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########排序前#############\n")
	for _, v := range mobile {
		fmt.Println(v.Brand, v.Price)
	}
	
	fmt.Println("\n\n########按价格排序[升序] ###########\n")
	sort.Sort(ByPrice(mobile))
	for _, v := range mobile {
		fmt.Println(v.Brand, v.Price)
	}	
	
	fmt.Println("\n\n########按品牌排序[降序] ########### \n")
	sort.Sort(ByBrand(mobile))
	for _, v := range mobile {
		fmt.Println(v.Brand, v.Price)
	}
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go ########排序前############# Sony 952 Nokia 468 Apple 1219 Samsung 1045 ########按价格排序[升序] ########### Nokia 468 Sony 952 Samsung 1045 Apple 1219 ########按品牌排序[降序] ########### Sony 952 Samsung 1045 Nokia 468 Apple 1219 C:\golang>

12)高朗 已排序 功能

已排序函数报告数据的排序依据是返回true还是false。下面的示例显示IsSorted()函数的用法:

句法:
func 已排序(data 接口) 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)))	// 假
	
	mobile2 := []Mobile{
		{"Sony", 452},
		{"Nokia", 768},
		{"Apple", 919},
		{"Samsung", 1045},
	}	
	fmt.Println("\nFound mobile2 price is sorted :", sort.IsSorted(ByPrice(mobile2)))	// 真正
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go 找到的mobile1价格排序:false 找到的mobile2价格排序:true C:\golang>

13)高朗 功能

给定提供的less函数,此Slice函数对提供的slice进行排序。如果提供的接口不是切片,则该函数会出现紧急情况。下面的示例显示Slice()函数的用法:

句法:
func 片(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########按品牌排序[升序] ###########\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########按品牌排序[降序] ########### \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########按价格排序[升序] ###########\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########按品牌排序[升序] ###########\n")
    for _, v := range mobile {
        fmt.Println(v.Brand, v.Price)
    }
	
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go ########按品牌排序[升序] ########### Apple 924 Nokia 700 Samsung 505 Sony 655 ########按品牌排序[降序] ########### Sony 655 Samsung 505 Nokia 700 Apple 924 ########按价格排序[升序] ########### Samsung 505 Sony 655 Nokia 700 Apple 924 ########按品牌排序[升序] ########### MI 900 OPPO 305 iPhone 924 sony 655 C:\golang>

14)高朗 片IsSorted 功能

片IsSorted函数测试切片是否已排序。如果数据已排序或返回false,则返回true。下面的示例显示SliceIsSorted()函数的用法:

句法:
func 片IsSorted(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) // 假
    
	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) // 真正
	
	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) // 假
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go 发现价格排序:错误 发现价格排序:true 找到的品牌已排序:错误 C:\golang>

15)高朗 切片

切片将Interface的方法附加到[] int,并按升序排序。 Len用于查找切片的长度。搜索返回将SearchInts应用于接收者和x的结果。 分类用于对切片进行排序。 下面的示例显示IntSlice()函数的用法:

句法:
type 切片 []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 片: ", sort.IntSlice.Len(s))	// 6
	fmt.Println("40 found in 片 at position: ", sort.IntSlice(s).Search(40))		//	4
	fmt.Println("82 found in 片 at position: ", sort.IntSlice(s).Search(82))		//	6
	fmt.Println("6 found in 片 at position: ", sort.IntSlice(s).Search(6))		//	0
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go [-10 9 22 33 40 54] Length of 片: 6 40在切片中的位置4上找到 82在切片中的位置6上找到 6在以下位置的切片中找到:1 C:\golang>

16)高朗 字符串切片

字符串切片将Interface的方法附加到[] string上,并按升序排序。 Len用于查找切片的长度。搜索返回将SearchStrings应用于接收者和x的结果。 分类用于对切片进行排序。下面的示例显示StringSlice函数的用法:

句法:
type 字符串切片 []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 片: ", sort.StringSlice.Len(s))	// 7
	fmt.Println("Texas found in 片 at position: ", sort.StringSlice(s).Search("Texas"))		//	5
	fmt.Println("Montana found in 片 at position: ", sort.StringSlice(s).Search("Montana"))	//	2
	fmt.Println("Utah found in 片 at position: ", sort.StringSlice(s).Search("Utah"))		//	6
	
	fmt.Println("OHIO found in 片 at position: ", sort.StringSlice(s).Search("OHIO"))		//	4
	fmt.Println("Ohio found in 片 at position: ", sort.StringSlice(s).Search("Ohio"))		//	4
	fmt.Println("ohio found in 片 at position: ", sort.StringSlice(s).Search("ohio"))		//	7
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go [阿拉斯加印第安纳州蒙大拿州内华达州俄亥俄州德克萨斯州华盛顿] Length of 片: 7 德克萨斯州在切片中的位置5发现 蒙大拿州的切片发现在位置:2 犹他州在Slice中的位置6发现 在切片中的OHIO位于位置4 俄亥俄州在切片中的位置4找到 俄亥俄州在切片中的位置7找到 C:\golang>

17)高朗 Float64Slice

Float64Slice将Interface的方法附加到[] float64上,并按升序排序。 Len用于查找切片的长度。搜索返回将SearchFloat64s应用于接收者和x的结果。 分类用于对切片进行排序。以下示例显示了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 片: ", sort.Float64Slice.Len(s))	// 5
	fmt.Println("123.32 found in 片 at position: ", sort.Float64Slice(s).Search(125.32))		//	3
	fmt.Println("999.15 found in 片 at position: ", sort.Float64Slice(s).Search(999.15))		//	5
	fmt.Println("12.14 found in 片 at position: ", sort.Float64Slice(s).Search(12.14))		//	0	
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go [14.74 63.14 85.201 125.32 965.25] Length of 片: 5 123.32在切片中的位置3中找到 切片中999.15的位置:5 12.14在切片中的位置0找到 C:\golang>

18)高朗 逆转 功能[降序]

反向功能以相反的顺序返回切片。下面的示例显示Reverse()函数的用法:

句法:
func 逆转(data 接口) 接口
例:
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)
}
运行该程序时,将得到以下输出:
C:\golang>go run sort.go [551 105 90 52 33 16 15 15 8 4] [-4 -8 -15 -15 -16 -33 -52 -90 -105 -551] [华盛顿德克萨斯州俄亥俄州内华达州蒙大拿州印第安纳州阿拉斯加] [印第安纳州华盛顿德克萨斯州俄亥俄州内华达州蒙大拿州阿拉斯加] [160.15 90.1 80.1 40.15 8.95] [-8.95 -40.15 -80.1 -90.1 -160.15] C:\golang>