sort.go

  1. package sort
  3. type Sorter interface {
  4.     Len() int
  5.     Less(i, j int) bool
  6.     Swap(i, j int)
  7. }
  9. func Sort(data Sorter) {
  10.     for pass := 1; pass < data.Len(); pass++ {
  11.         for i := 0; i < data.Len()-pass; i++ {
  12.             if data.Less(i+1, i) {
  13.                 data.Swap(i, i+1)
  14.             }
  15.         }
  16.     }
  17. }
  18. func IsSorted(data Sorter) bool {
  19.     n := data.Len()
  20.     for i := n - 1; i > 0; i-- {
  21.         if data.Less(i, i-1) {
  22.             return false
  23.         }
  24.     }
  25.     return true
  26. }
  28. // Convenience types for common cases
  29. type IntArray []int
  31. func (p IntArray) Len() int           { return len(p) }
  32. func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }
  33. func (p IntArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
  35. type StringArray []string
  37. func (p StringArray) Len() int           { return len(p) }
  38. func (p StringArray) Less(i, j int) bool { return p[i] < p[j] }
  39. func (p StringArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
  41. // Convenience wrappers for common cases
  42. func SortInts(a []int)                 { Sort(IntArray(a)) }
  43. func SortStrings(a []string)           { Sort(StringArray(a)) }
  44. func IntsAreSorted(a []int) bool       { return IsSorted(IntArray(a)) }
  45. func StringsAreSorted(a []string) bool { return IsSorted(StringArray(a)) }

main.go

  1. package main
  3. import (
  4.     "fmt"
  6.     "./sort"
  7. )
  9. func ints() {
  10.     data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
  11.     a := sort.IntArray(data) //conversion to type IntArray
  12.     sort.Sort(a)
  13.     if !sort.IsSorted(a) {
  14.         panic("fails")
  15.     }
  16.     fmt.Printf("The sorted array is: %v\n", a)
  17. }
  18. func strings() {
  19.     data := []string{"monday", "friday", "tuesday", "wednesday", "sunday", "thursday", "", "saturday"}
  20.     a := sort.StringArray(data)
  21.     sort.Sort(a)
  22.     if !sort.IsSorted(a) {
  23.         panic("fail")
  24.     }
  25.     fmt.Printf("The sorted array is: %v\n", a)
  26. }
  28. type day struct {
  29.     num       int
  30.     shortName string
  31.     longName  string
  32. }
  33. type dayArray struct {
  34.     data []*day
  35. }
  37. func (p *dayArray) Len() int           { return len(p.data) }
  38. func (p *dayArray) Less(i, j int) bool { return p.data[i].num < p.data[j].num }
  39. func (p *dayArray) Swap(i, j int)      { p.data[i], p.data[j] = p.data[j], p.data[i] }
  40. func days() {
  41.     Sunday := day{0, "SUN", "Sunday"}
  42.     Monday := day{1, "MON", "Monday"}
  43.     Tuesday := day{2, "TUE", "Tuesday"}
  44.     Wednesday := day{3, "WED", "Wednesday"}
  45.     Thursday := day{4, "THU", "Thursday"}
  46.     Friday := day{5, "FRI", "Friday"}
  47.     Saturday := day{6, "SAT", "Saturday"}
  48.     data := []*day{&Tuesday, &Thursday, &Wednesday, &Sunday, &Monday, &Friday, &Saturday}
  49.     a := dayArray{data}
  50.     sort.Sort(&a)
  51.     if !sort.IsSorted(&a) {
  52.         panic("fail")
  53.     }
  54.     for _, d := range data {
  55.         fmt.Printf("%s ", d.longName)
  56.     }
  57.     fmt.Printf("\n")
  58. }
  59. func main() {
  60.     ints()
  61.     strings()
  62.     days()
  63. }

output

  1. The sorted array is: [-5467984 -784 0 0 42 59 74 238 905 959 7586 7586 9845]
  2. The sorted array is: [ friday monday saturday sunday thursday tuesday wednesday]
  3. Sunday Monday Tuesday Wednesday Thursday Friday Saturday