Go stdlib (2) : sort

godoc.org/sort

Package sort

 

슬라이스를 sorting 할 수 있습니다. godoc에 example이 참 잘되어 있습니다. 그곳을 보고 공부하는 게 좋습니다.

 

Int 슬라이스 정렬

 

func main() {
	s := []int{5, 2, 6, 3, 1, 4}       // unsorted
	fmt.Println(sort.IntsAreSorted(s)) // false
	sort.Ints(s)                       // return이 없음. sorting만 함
	fmt.Println(s)                     // [1, 2, 3, 4, 5, 6]
	fmt.Println(sort.IntsAreSorted(s)) // true
}

 

float64 슬라이스 정렬

float32를 인자로 넣으면 에러가 납니다. float32 슬라이스 정렬이 있는지 알아봤는데 없습니다.

func main() {
	s := []float64{1.12, 3.25, 2.23, 6.34, 4.23}
	fmt.Println(sort.Float64sAreSorted(s)) // false
	sort.Float64s(s)                       // 정렬
	fmt.Println(s)
	fmt.Println(sort.Float64sAreSorted(s)) // true
}

 

float32 슬라이스 정렬을 해야겠다면 float64로 변경하던지, 아래 처럼 직접 비교해야 합니다.

sort.Slice(float32Values, func(i, j int) bool { return float32Values[i] < float32Values[j] })

 

string 슬라이스 정렬

func main() {
	s := []string{"apple", "orange", "banana", "pizza"}
	sort.Strings(s)
	fmt.Println(s)
}

 

 

struct 슬라이스 정렬

sort.SliceStable 를 통해 가능합니다.

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

type person struct {
	name string
	age  int
}

func main() {
	s := []person{{"todd", 45}, {"darren", 38}, {"weeb", 27}, {"arron", 22}}
	sort.SliceStable(s, func(i, j int) bool {
		return s[i].age < s[j].age
	})
	fmt.Println(s)

}

 

 

Sort custom data structures

underlying type을 이용해 정렬하는 방법입니다. struct들의 슬라이스를 특정 기준에 따라 정렬하려면 sort.Sort를 활용하여야 합니다.

func Sort(data Interface)

 

interface라는 타입을 가진 data를 인자로 넘겨야 하는군요

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.

 

godoc.org/sort#Interface

interface 이름이 interface입니다. ㅋㅋ

Len, Less, Swap 메서드를 구현하면 암시적으로, 자동으로 interface interface가 됩니다.

type Interface interface {
    // Len is the number of elements in the collection.
    Len() int
    // Less reports whether the element with
    // index i should sort before the element with index j.
    Less(i, j int) bool
    // Swap swaps the elements with indexes i and j.
    Swap(i, j int)
}

 

이를 활용하면 아래와 같이 struct slice를 정렬할 수 있습니다.

type person struct {
	name string
	age  int
}

// 나이 순으로 정렬하기
type byAge []person

func (a byAge) Len() int {
	return len(a)
}
func (a byAge) Less(i, j int) bool {
	return a[i].age < a[j].age
}
func (a byAge) Swap(i, j int) {
	a[i], a[j] = a[j], a[i]
}

// 이름 순으로 정렬하기
type byName []person

func (a byName) Len() int { return len(a) }
func (a byName) Less(i, j int) bool {
	return a[i].name[0] < a[j].name[0]
}
func (a byName) Swap(i, j int) {
	a[i], a[j] = a[j], a[i]
}

func main() {
	s := []person{{"todd", 45}, {"darren", 38}, {"weeb", 27}, {"arron", 22}}
	sort.Sort(byAge(s))
	fmt.Println(s)
	sort.Sort(byName(s))
	fmt.Println(s)
}