Sort a custom struct array in GoLang

How do I sort a custom array of struct using GoLang.

My Code is :

package main

import "fmt"

type TicketDistribution struct {
	Label        string
	TicketVolume int64
}

type TicketDistributionResponse struct {
	LevelDistribution []*TicketDistribution
}

func main() {
	var response TicketDistributionResponse

	response.LevelDistribution = append(response.LevelDistribution, &TicketDistribution{Label: "John", TicketVolume: 3})
	response.LevelDistribution = append(response.LevelDistribution, &TicketDistribution{Label: "Bill", TicketVolume: 7})
	response.LevelDistribution = append(response.LevelDistribution, &TicketDistribution{Label: "Sam", TicketVolume: 4})

	for _, val := range response.LevelDistribution {
		fmt.Println(*val)
	}

}

This prints the output as

{John 3}
{Bill 7}
{Sam 4}

I want to sort the response object by TicketVolume value in descending order.

After the sort the response object should look like :

{Bill 7}
{Sam 4}
{John 3}

You can use sort.Slice for that. It takes your slice and a sort function.
The sort function itself takes two indices and returns true if the left item is smaller than the right one.

This way you can sort by your own custom criteria.

package main

import (
	"fmt"
	"sort"
)

type TicketDistribution struct {
	Label        string
	TicketVolume int64
}

type TicketDistributionResponse struct {
	LevelDistribution []*TicketDistribution
}

func main() {
	var response TicketDistributionResponse

	response.LevelDistribution = append(response.LevelDistribution, &TicketDistribution{Label: "John", TicketVolume: 3})
	response.LevelDistribution = append(response.LevelDistribution, &TicketDistribution{Label: "Bill", TicketVolume: 7})
	response.LevelDistribution = append(response.LevelDistribution, &TicketDistribution{Label: "Sam", TicketVolume: 4})

	sort.Slice(response.LevelDistribution, func(i, j int) bool {
		a := response.LevelDistribution[i]
		b := response.LevelDistribution[j]
		return a.TicketVolume > b.TicketVolume
	})

	for _, val := range response.LevelDistribution {
		fmt.Println(*val)
	}
}

The use of > in the comparison function sorts the slice descendingly, for ascending order you would use <.

You can use slice.Interface also. You can implement the sort.Interface interface for your struct by defining these three methods.

type Interface interface {
	// Len is the number of elements in the collection.
	Len() int

	// Less reports whether the element with index i
	// must 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)
}

Performance: Sorting Slice vs Sorting Type (of Slice) with Sort implementation
> The general sort.Slice() and sort.SliceStable() functions work on any slices. You have to pass your slice value as an interface{} value, and the implementation has to use reflection (the reflect package) to access its elements and length, and to perform the swaps of elements.

> In contrast, when you implement the sort.Interface type yourself, in your implementation you have access to the static type of your slice, and you can provide the implementation of the sort.Interface without relfection, this is what will make it faster.

Here is the updated code

package main

import (
	"fmt"
	"sort"
)

type TicketDistribution struct {
	Label        string
	TicketVolume int64
}

type LevelDistribution []*TicketDistribution

func (ld LevelDistribution) Len() int {
	return len(ld)
}
func (ld LevelDistribution) Swap(i, j int) {
	ld[i], ld[j] = ld[j], ld[i]
}
func (ld LevelDistribution) Less(i, j int) bool {
	return ld[i].TicketVolume > ld[j].TicketVolume
}

type TicketDistributionResponse struct {
	LevelDistribution LevelDistribution
}

func main() {
	var response TicketDistributionResponse

	response.LevelDistribution = append(response.LevelDistribution, &TicketDistribution{Label: "John", TicketVolume: 3})
	response.LevelDistribution = append(response.LevelDistribution, &TicketDistribution{Label: "Bill", TicketVolume: 7})
	response.LevelDistribution = append(response.LevelDistribution, &TicketDistribution{Label: "Sam", TicketVolume: 4})

	ld := LevelDistribution(response.LevelDistribution)
	sort.Sort(ld)

	for _, val := range response.LevelDistribution {
		fmt.Println(*val)
	}
}

Here is the benchmark run output looks like the interface/struct method is better there too

> go test -bench=. -benchmem

goos: linux
goarch: amd64
pkg: solutions/golang/sort
cpu: 11th Gen Intel(R) Core(TM) i5-11320H @ 3.20GHz
BenchmarkWithInterface-8   	 5368116	       191.0 ns/op	     152 B/op	       7 allocs/op
BenchmarkWithSlice-8       	 5085151	       234.9 ns/op	     184 B/op	       8 allocs/op
PASS