version: 1.10

package sort

import "sort"

Overview

Package sort provides primitives for sorting slices and user-defined collections.

Example:

  1. package sort_test
  3. import (
  4.     "fmt"
  5.     "sort"
  6. )
  8. type Person struct {
  9.     Name string
  10.     Age  int
  11. }
  13. func (p Person) String() string {
  14.     return fmt.Sprintf("%s: %d", p.Name, p.Age)
  15. }
  17. // ByAge implements sort.Interface for []Person based on
  18. // the Age field.
  19. type ByAge []Person
  21. func (a ByAge) Len() int           { return len(a) }
  22. func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
  23. func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
  25. func Example() {
  26.     people := []Person{
  27.         {"Bob", 31},
  28.         {"John", 42},
  29.         {"Michael", 17},
  30.         {"Jenny", 26},
  31.     }
  33.     fmt.Println(people)
  34.     // There are two ways to sort a slice. First, one can define
  35.     // a set of methods for the slice type, as with ByAge, and
  36.     // call sort.Sort. In this first example we use that technique.
  37.     sort.Sort(ByAge(people))
  38.     fmt.Println(people)
  40.     // The other way is to use sort.Slice with a custom Less
  41.     // function, which can be provided as a closure. In this
  42.     // case no methods are needed. (And if they exist, they
  43.     // are ignored.) Here we re-sort in reverse order: compare
  44.     // the closure with ByAge.Less.
  45.     sort.Slice(people, func(i, j int) bool {
  46.         return people[i].Age > people[j].Age
  47.     })
  48.     fmt.Println(people)
  50.     // Output:
  51.     // [Bob: 31 John: 42 Michael: 17 Jenny: 26]
  52.     // [Michael: 17 Jenny: 26 Bob: 31 John: 42]
  53.     // [John: 42 Bob: 31 Jenny: 26 Michael: 17]
  54. }

Example:

  1. package sort_test
  3. import (
  4.     "fmt"
  5.     "sort"
  6. )
  8. // A couple of type definitions to make the units clear.
  9. type earthMass float64
  10. type au float64
  12. // A Planet defines the properties of a solar system object.
  13. type Planet struct {
  14.     name     string
  15.     mass     earthMass
  16.     distance au
  17. }
  19. // By is the type of a "less" function that defines the ordering of its Planet arguments.
  20. type By func(p1, p2 *Planet) bool
  22. // Sort is a method on the function type, By, that sorts the argument slice according to the function.
  23. func (by By) Sort(planets []Planet) {
  24.     ps := &planetSorter{
  25.         planets: planets,
  26.         by:      by, // The Sort method's receiver is the function (closure) that defines the sort order.
  27.     }
  28.     sort.Sort(ps)
  29. }
  31. // planetSorter joins a By function and a slice of Planets to be sorted.
  32. type planetSorter struct {
  33.     planets []Planet
  34.     by      func(p1, p2 *Planet) bool // Closure used in the Less method.
  35. }
  37. // Len is part of sort.Interface.
  38. func (s *planetSorter) Len() int {
  39.     return len(s.planets)
  40. }
  42. // Swap is part of sort.Interface.
  43. func (s *planetSorter) Swap(i, j int) {
  44.     s.planets[i], s.planets[j] = s.planets[j], s.planets[i]
  45. }
  47. // Less is part of sort.Interface. It is implemented by calling the "by" closure in the sorter.
  48. func (s *planetSorter) Less(i, j int) bool {
  49.     return s.by(&s.planets[i], &s.planets[j])
  50. }
  52. var planets = []Planet{
  53.     {"Mercury", 0.055, 0.4},
  54.     {"Venus", 0.815, 0.7},
  55.     {"Earth", 1.0, 1.0},
  56.     {"Mars", 0.107, 1.5},
  57. }
  59. // ExampleSortKeys demonstrates a technique for sorting a struct type using programmable sort criteria.
  60. func Example_sortKeys() {
  61.     // Closures that order the Planet structure.
  62.     name := func(p1, p2 *Planet) bool {
  63.         return p1.name < p2.name
  64.     }
  65.     mass := func(p1, p2 *Planet) bool {
  66.         return p1.mass < p2.mass
  67.     }
  68.     distance := func(p1, p2 *Planet) bool {
  69.         return p1.distance < p2.distance
  70.     }
  71.     decreasingDistance := func(p1, p2 *Planet) bool {
  72.         return distance(p2, p1)
  73.     }
  75.     // Sort the planets by the various criteria.
  76.     By(name).Sort(planets)
  77.     fmt.Println("By name:", planets)
  79.     By(mass).Sort(planets)
  80.     fmt.Println("By mass:", planets)
  82.     By(distance).Sort(planets)
  83.     fmt.Println("By distance:", planets)
  85.     By(decreasingDistance).Sort(planets)
  86.     fmt.Println("By decreasing distance:", planets)
  88.     // Output: By name: [{Earth 1 1} {Mars 0.107 1.5} {Mercury 0.055 0.4} {Venus 0.815 0.7}]
  89.     // By mass: [{Mercury 0.055 0.4} {Mars 0.107 1.5} {Venus 0.815 0.7} {Earth 1 1}]
  90.     // By distance: [{Mercury 0.055 0.4} {Venus 0.815 0.7} {Earth 1 1} {Mars 0.107 1.5}]
  91.     // By decreasing distance: [{Mars 0.107 1.5} {Earth 1 1} {Venus 0.815 0.7} {Mercury 0.055 0.4}]
  92. }

Example:

  1. package sort_test
  3. import (
  4.     "fmt"
  5.     "sort"
  6. )
  8. // A Change is a record of source code changes, recording user, language, and delta size.
  9. type Change struct {
  10.     user     string
  11.     language string
  12.     lines    int
  13. }
  15. type lessFunc func(p1, p2 *Change) bool
  17. // multiSorter implements the Sort interface, sorting the changes within.
  18. type multiSorter struct {
  19.     changes []Change
  20.     less    []lessFunc
  21. }
  23. // Sort sorts the argument slice according to the less functions passed to OrderedBy.
  24. func (ms *multiSorter) Sort(changes []Change) {
  25.     ms.changes = changes
  26.     sort.Sort(ms)
  27. }
  29. // OrderedBy returns a Sorter that sorts using the less functions, in order.
  30. // Call its Sort method to sort the data.
  31. func OrderedBy(less ...lessFunc) *multiSorter {
  32.     return &multiSorter{
  33.         less: less,
  34.     }
  35. }
  37. // Len is part of sort.Interface.
  38. func (ms *multiSorter) Len() int {
  39.     return len(ms.changes)
  40. }
  42. // Swap is part of sort.Interface.
  43. func (ms *multiSorter) Swap(i, j int) {
  44.     ms.changes[i], ms.changes[j] = ms.changes[j], ms.changes[i]
  45. }
  47. // Less is part of sort.Interface. It is implemented by looping along the
  48. // less functions until it finds a comparison that discriminates between
  49. // the two items (one is less than the other). Note that it can call the
  50. // less functions twice per call. We could change the functions to return
  51. // -1, 0, 1 and reduce the number of calls for greater efficiency: an
  52. // exercise for the reader.
  53. func (ms *multiSorter) Less(i, j int) bool {
  54.     p, q := &ms.changes[i], &ms.changes[j]
  55.     // Try all but the last comparison.
  56.     var k int
  57.     for k = 0; k < len(ms.less)-1; k++ {
  58.         less := ms.less[k]
  59.         switch {
  60.         case less(p, q):
  61.             // p < q, so we have a decision.
  62.             return true
  63.         case less(q, p):
  64.             // p > q, so we have a decision.
  65.             return false
  66.         }
  67.         // p == q; try the next comparison.
  68.     }
  69.     // All comparisons to here said "equal", so just return whatever
  70.     // the final comparison reports.
  71.     return ms.less[k](p, q)
  72. }
  74. var changes = []Change{
  75.     {"gri", "Go", 100},
  76.     {"ken", "C", 150},
  77.     {"glenda", "Go", 200},
  78.     {"rsc", "Go", 200},
  79.     {"r", "Go", 100},
  80.     {"ken", "Go", 200},
  81.     {"dmr", "C", 100},
  82.     {"r", "C", 150},
  83.     {"gri", "Smalltalk", 80},
  84. }
  86. // ExampleMultiKeys demonstrates a technique for sorting a struct type using different
  87. // sets of multiple fields in the comparison. We chain together "Less" functions, each of
  88. // which compares a single field.
  89. func Example_sortMultiKeys() {
  90.     // Closures that order the Change structure.
  91.     user := func(c1, c2 *Change) bool {
  92.         return c1.user < c2.user
  93.     }
  94.     language := func(c1, c2 *Change) bool {
  95.         return c1.language < c2.language
  96.     }
  97.     increasingLines := func(c1, c2 *Change) bool {
  98.         return c1.lines < c2.lines
  99.     }
  100.     decreasingLines := func(c1, c2 *Change) bool {
  101.         return c1.lines > c2.lines // Note: > orders downwards.
  102.     }
  104.     // Simple use: Sort by user.
  105.     OrderedBy(user).Sort(changes)
  106.     fmt.Println("By user:", changes)
  108.     // More examples.
  109.     OrderedBy(user, increasingLines).Sort(changes)
  110.     fmt.Println("By user,<lines:", changes)
  112.     OrderedBy(user, decreasingLines).Sort(changes)
  113.     fmt.Println("By user,>lines:", changes)
  115.     OrderedBy(language, increasingLines).Sort(changes)
  116.     fmt.Println("By language,<lines:", changes)
  118.     OrderedBy(language, increasingLines, user).Sort(changes)
  119.     fmt.Println("By language,<lines,user:", changes)
  121.     // Output:
  122.     // By user: [{dmr C 100} {glenda Go 200} {gri Go 100} {gri Smalltalk 80} {ken C 150} {ken Go 200} {r Go 100} {r C 150} {rsc Go 200}]
  123.     // By user,<lines: [{dmr C 100} {glenda Go 200} {gri Smalltalk 80} {gri Go 100} {ken C 150} {ken Go 200} {r Go 100} {r C 150} {rsc Go 200}]
  124.     // By user,>lines: [{dmr C 100} {glenda Go 200} {gri Go 100} {gri Smalltalk 80} {ken Go 200} {ken C 150} {r C 150} {r Go 100} {rsc Go 200}]
  125.     // By language,<lines: [{dmr C 100} {ken C 150} {r C 150} {r Go 100} {gri Go 100} {ken Go 200} {glenda Go 200} {rsc Go 200} {gri Smalltalk 80}]
  126.     // By language,<lines,user: [{dmr C 100} {ken C 150} {r C 150} {gri Go 100} {r Go 100} {glenda Go 200} {ken Go 200} {rsc Go 200} {gri Smalltalk 80}]
  128. }

Example:

  1. package sort_test
  3. import (
  4.     "fmt"
  5.     "sort"
  6. )
  8. type Grams int
  10. func (g Grams) String() string { return fmt.Sprintf("%dg", int(g)) }
  12. type Organ struct {
  13.     Name   string
  14.     Weight Grams
  15. }
  17. type Organs []*Organ
  19. func (s Organs) Len() int      { return len(s) }
  20. func (s Organs) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
  22. // ByName implements sort.Interface by providing Less and using the Len and
  23. // Swap methods of the embedded Organs value.
  24. type ByName struct{ Organs }
  26. func (s ByName) Less(i, j int) bool { return s.Organs[i].Name < s.Organs[j].Name }
  28. // ByWeight implements sort.Interface by providing Less and using the Len and
  29. // Swap methods of the embedded Organs value.
  30. type ByWeight struct{ Organs }
  32. func (s ByWeight) Less(i, j int) bool { return s.Organs[i].Weight < s.Organs[j].Weight }
  34. func Example_sortWrapper() {
  35.     s := []*Organ{
  36.         {"brain", 1340},
  37.         {"heart", 290},
  38.         {"liver", 1494},
  39.         {"pancreas", 131},
  40.         {"prostate", 62},
  41.         {"spleen", 162},
  42.     }
  44.     sort.Sort(ByWeight{s})
  45.     fmt.Println("Organs by weight:")
  46.     printOrgans(s)
  48.     sort.Sort(ByName{s})
  49.     fmt.Println("Organs by name:")
  50.     printOrgans(s)
  52.     // Output:
  53.     // Organs by weight:
  54.     // prostate (62g)
  55.     // pancreas (131g)
  56.     // spleen   (162g)
  57.     // heart    (290g)
  58.     // brain    (1340g)
  59.     // liver    (1494g)
  60.     // Organs by name:
  61.     // brain    (1340g)
  62.     // heart    (290g)
  63.     // liver    (1494g)
  64.     // pancreas (131g)
  65.     // prostate (62g)
  66.     // spleen   (162g)
  67. }
  69. func printOrgans(s []*Organ) {
  70.     for _, o := range s {
  71.         fmt.Printf("%-8s (%v)\n", o.Name, o.Weight)
  72.     }
  73. }

Index

Examples

Package files

search.go slice.go sort.go zfuncversion.go

func Float64s 

  1. func Float64s(a []float64)

Float64s sorts a slice of float64s in increasing order (not-a-number values are treated as less than other values).

Example:

  1. s := []float64{5.2, -1.3, 0.7, -3.8, 2.6} // unsorted
  2. sort.Float64s(s)
  3. fmt.Println(s)
  5. s = []float64{math.Inf(1), math.NaN(), math.Inf(-1), 0.0} // unsorted
  6. sort.Float64s(s)
  7. fmt.Println(s)
  9. // Output: [-3.8 -1.3 0.7 2.6 5.2]
  10. // [NaN -Inf 0 +Inf]

func Float64sAreSorted 

  1. func Float64sAreSorted(a []float64) bool

Float64sAreSorted tests whether a slice of float64s is sorted in increasing order (not-a-number values are treated as less than other values).

Example:

  1. s := []float64{0.7, 1.3, 2.6, 3.8, 5.2} // sorted ascending
  2. fmt.Println(sort.Float64sAreSorted(s))
  4. s = []float64{5.2, 3.8, 2.6, 1.3, 0.7} // sorted descending
  5. fmt.Println(sort.Float64sAreSorted(s))
  7. s = []float64{5.2, 1.3, 0.7, 3.8, 2.6} // unsorted
  8. fmt.Println(sort.Float64sAreSorted(s))
  10. // Output: true
  11. // false
  12. // false

func Ints 

  1. func Ints(a []int)

Ints sorts a slice of ints in increasing order.

Example:

  1. s := []int{5, 2, 6, 3, 1, 4} // unsorted
  2. sort.Ints(s)
  3. fmt.Println(s)
  4. // Output: [1 2 3 4 5 6]

func IntsAreSorted 

  1. func IntsAreSorted(a []int) bool

IntsAreSorted tests whether a slice of ints is sorted in increasing order.

Example:

  1. s := []int{1, 2, 3, 4, 5, 6} // sorted ascending
  2. fmt.Println(sort.IntsAreSorted(s))
  4. s = []int{6, 5, 4, 3, 2, 1} // sorted descending
  5. fmt.Println(sort.IntsAreSorted(s))
  7. s = []int{3, 2, 4, 1, 5} // unsorted
  8. fmt.Println(sort.IntsAreSorted(s))
  10. // Output: true
  11. // false
  12. // false

func IsSorted 

  1. func IsSorted(data Interface) bool

IsSorted reports whether data is sorted.

  1. func Search(n int, f func(int) bool) int

Search uses binary search to find and return the smallest index i in [0, n) at which f(i) is true, assuming that on the range [0, n), f(i) == true implies f(i+1) == true. That is, Search requires that f is false for some (possibly empty) prefix of the input range [0, n) and then true for the (possibly empty) remainder; Search returns the first true index. If there is no such index, Search returns n. (Note that the “not found” return value is not -1 as in, for instance, strings.Index.) Search calls f(i) only for i in the range [0, n).

A common use of Search is to find the index i for a value x in a sorted, indexable data structure such as an array or slice. In this case, the argument f, typically a closure, captures the value to be searched for, and how the data structure is indexed and ordered.

For instance, given a slice data sorted in ascending order, the call Search(len(data), func(i int) bool { return data[i] >= 23 }) returns the smallest index i such that data[i] >= 23. If the caller wants to find whether 23 is in the slice, it must test data[i] == 23 separately.

Searching data sorted in descending order would use the <= operator instead of the >= operator.

To complete the example above, the following code tries to find the value x in an integer slice data sorted in ascending order:

  1. x := 23
  2. i := sort.Search(len(data), func(i int) bool { return data[i] >= x })
  3. if i < len(data) && data[i] == x {
  4.     // x is present at data[i]
  5. } else {
  6.     // x is not present in data,
  7.     // but i is the index where it would be inserted.
  8. }

As a more whimsical example, this program guesses your number:

  1. func GuessingGame() {
  2.     var s string
  3.     fmt.Printf("Pick an integer from 0 to 100.\n")
  4.     answer := sort.Search(100, func(i int) bool {
  5.         fmt.Printf("Is your number <= %d? ", i)
  6.         fmt.Scanf("%s", &s)
  7.         return s != "" && s[0] == 'y'
  8.     })
  9.     fmt.Printf("Your number is %d.\n", answer)
  10. }

Example:

  1. a := []int{1, 3, 6, 10, 15, 21, 28, 36, 45, 55}
  2. x := 6
  4. i := sort.Search(len(a), func(i int) bool { return a[i] >= x })
  5. if i < len(a) && a[i] == x {
  6.     fmt.Printf("found %d at index %d in %v\n", x, i, a)
  7. } else {
  8.     fmt.Printf("%d not found in %v\n", x, a)
  9. }
  10. // Output:
  11. // found 6 at index 2 in [1 3 6 10 15 21 28 36 45 55]

Example:

  1. a := []int{55, 45, 36, 28, 21, 15, 10, 6, 3, 1}
  2. x := 6
  4. i := sort.Search(len(a), func(i int) bool { return a[i] <= x })
  5. if i < len(a) && a[i] == x {
  6.     fmt.Printf("found %d at index %d in %v\n", x, i, a)
  7. } else {
  8.     fmt.Printf("%d not found in %v\n", x, a)
  9. }
  10. // Output:
  11. // found 6 at index 7 in [55 45 36 28 21 15 10 6 3 1]

func SearchFloat64s 

  1. func SearchFloat64s(a []float64, x float64) int

SearchFloat64s searches for x in a sorted slice of float64s and returns the index as specified by Search. The return value is the index to insert x if x is not present (it could be len(a)). The slice must be sorted in ascending order.

func SearchInts 

  1. func SearchInts(a []int, x int) int

SearchInts searches for x in a sorted slice of ints and returns the index as specified by Search. The return value is the index to insert x if x is not present (it could be len(a)). The slice must be sorted in ascending order.

func SearchStrings 

  1. func SearchStrings(a []string, x string) int

SearchStrings searches for x in a sorted slice of strings and returns the index as specified by Search. The return value is the index to insert x if x is not present (it could be len(a)). The slice must be sorted in ascending order.

func Slice 

  1. func Slice(slice interface{}, less func(i, j int) bool)

Slice sorts the provided slice given the provided less function.

The sort is not guaranteed to be stable. For a stable sort, use SliceStable.

The function panics if the provided interface is not a slice.

Example:

  1. people := []struct {
  2.     Name string
  3.     Age  int
  4. }{
  5.     {"Gopher", 7},
  6.     {"Alice", 55},
  7.     {"Vera", 24},
  8.     {"Bob", 75},
  9. }
  10. sort.Slice(people, func(i, j int) bool { return people[i].Name < people[j].Name })
  11. fmt.Println("By name:", people)
  13. sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age })
  14. fmt.Println("By age:", people)
  15. // Output: By name: [{Alice 55} {Bob 75} {Gopher 7} {Vera 24}]
  16. // By age: [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]

func SliceIsSorted 

  1. func SliceIsSorted(slice interface{}, less func(i, j int) bool) bool

SliceIsSorted tests whether a slice is sorted.

The function panics if the provided interface is not a slice.

func SliceStable 

  1. func SliceStable(slice interface{}, less func(i, j int) bool)

SliceStable sorts the provided slice given the provided less function while keeping the original order of equal elements.

The function panics if the provided interface is not a slice.

Example:

  1. people := []struct {
  2.     Name string
  3.     Age  int
  4. }{
  5.     {"Alice", 25},
  6.     {"Elizabeth", 75},
  7.     {"Alice", 75},
  8.     {"Bob", 75},
  9.     {"Alice", 75},
  10.     {"Bob", 25},
  11.     {"Colin", 25},
  12.     {"Elizabeth", 25},
  13. }
  15. // Sort by name, preserving original order
  16. sort.SliceStable(people, func(i, j int) bool { return people[i].Name < people[j].Name })
  17. fmt.Println("By name:", people)
  19. // Sort by age preserving name order
  20. sort.SliceStable(people, func(i, j int) bool { return people[i].Age < people[j].Age })
  21. fmt.Println("By age,name:", people)
  23. // Output: By name: [{Alice 25} {Alice 75} {Alice 75} {Bob 75} {Bob 25} {Colin 25} {Elizabeth 75} {Elizabeth 25}]
  24. // By age,name: [{Alice 25} {Bob 25} {Colin 25} {Elizabeth 25} {Alice 75} {Alice 75} {Bob 75} {Elizabeth 75}]

func Sort 

  1. func Sort(data Interface)

Sort sorts data. It makes one call to data.Len to determine n, and O(n*log(n)) calls to data.Less and data.Swap. The sort is not guaranteed to be stable.

func Stable 

  1. func Stable(data Interface)

Stable sorts data while keeping the original order of equal elements.

It makes one call to data.Len to determine n, O(nlog(n)) calls to data.Less and O(nlog(n)*log(n)) calls to data.Swap.

func Strings 

  1. func Strings(a []string)

Strings sorts a slice of strings in increasing order.

Example:

  1. s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
  2. sort.Strings(s)
  3. fmt.Println(s)
  4. // Output: [Alpha Bravo Delta Go Gopher Grin]

func StringsAreSorted 

  1. func StringsAreSorted(a []string) bool

StringsAreSorted tests whether a slice of strings is sorted in increasing order.

type Float64Slice 

  1. type Float64Slice []float64

Float64Slice attaches the methods of Interface to []float64, sorting in increasing order (not-a-number values are treated as less than other values).

func (Float64Slice) Len 

  1. func (p Float64Slice) Len() int

func (Float64Slice) Less 

  1. func (p Float64Slice) Less(i, j int) bool

func (Float64Slice) Search 

  1. func (p Float64Slice) Search(x float64) int

Search returns the result of applying SearchFloat64s to the receiver and x.

func (Float64Slice) Sort 

  1. func (p Float64Slice) Sort()

Sort is a convenience method.

func (Float64Slice) Swap 

  1. func (p Float64Slice) Swap(i, j int)

type IntSlice 

  1. type IntSlice []int

IntSlice attaches the methods of Interface to []int, sorting in increasing order.

func (IntSlice) Len 

  1. func (p IntSlice) Len() int

func (IntSlice) Less 

  1. func (p IntSlice) Less(i, j int) bool

func (IntSlice) Search 

  1. func (p IntSlice) Search(x int) int

Search returns the result of applying SearchInts to the receiver and x.

func (IntSlice) Sort 

  1. func (p IntSlice) Sort()

Sort is a convenience method.

func (IntSlice) Swap 

  1. func (p IntSlice) Swap(i, j int)

type Interface 

  1. type Interface interface {
  2.     // Len is the number of elements in the collection.
  3.     Len() int
  4.     // Less reports whether the element with
  5.     // index i should sort before the element with index j.
  6.     Less(i, j int) bool
  7.     // Swap swaps the elements with indexes i and j.
  8.     Swap(i, j int)
  9. }

A type, typically a collection, that satisfies sort.Interface can be sorted by the routines in this package. The methods require that the elements of the collection be enumerated by an integer index.

func Reverse 

  1. func Reverse(data Interface) Interface

Reverse returns the reverse order for data.

Example:

  1. s := []int{5, 2, 6, 3, 1, 4} // unsorted
  2. sort.Sort(sort.Reverse(sort.IntSlice(s)))
  3. fmt.Println(s)
  4. // Output: [6 5 4 3 2 1]

type StringSlice 

  1. type StringSlice []string

StringSlice attaches the methods of Interface to []string, sorting in increasing order.

func (StringSlice) Len 

  1. func (p StringSlice) Len() int

func (StringSlice) Less 

  1. func (p StringSlice) Less(i, j int) bool

func (StringSlice) Search 

  1. func (p StringSlice) Search(x string) int

Search returns the result of applying SearchStrings to the receiver and x.

func (StringSlice) Sort 

  1. func (p StringSlice) Sort()

Sort is a convenience method.

func (StringSlice) Swap 

  1. func (p StringSlice) Swap(i, j int)