快捷導(dǎo)航

golang中按照結(jié)構(gòu)體的某個字段排序?qū)嵗a

更新時間：2022年05月29日 15:12:49 作者：raoxiaoya

在任何編程語言中,關(guān)乎到數(shù)據(jù)的排序都會有對應(yīng)的策略,下面這篇文章主要給大家介紹了關(guān)于golang中按照結(jié)構(gòu)體的某個字段排序的相關(guān)資料,需要的朋友可以參考下

概述

golang的sort包默認支持int, float64, string的從小大到排序：

int -> Ints(x []int)
float64 -> Float64s(x []float64)
string -> Strings(x []string)

同時它還提供了自定義的排序接口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)
}

golang默認提供了三個類型，他們都實現(xiàn)了Interface：
Float64Slice
IntSlice
StringSlice

從大到小排序

方法1：先使用提供的從大到小排序，再翻轉(zhuǎn)

arr := []float64{0.1, 0.5, 0.8, 0.4, 0.2}

sort.Sort(sort.Reverse(sort.Float64Slice(arr)))
fmt.Println(arr) // [0.8 0.5 0.4 0.2 0.1]

方法二：自定義類型實現(xiàn)

type Float64SliceDecrement []float64
func (s Float64SliceDecrement) Len() int { return len(s) }
func (s Float64SliceDecrement) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s Float64SliceDecrement) Less(i, j int) bool { return s[i] > s[j] }
func main() {
	arr := []float64{0.1, 0.5, 0.8, 0.4, 0.2}
	
	sort.Sort(Float64SliceDecrement(arr))
	fmt.Println(arr) // [0.8 0.5 0.4 0.2 0.1]
}

按照結(jié)構(gòu)體的某個字段排序

按年紀從大到小排序

type Persons struct {
	Age int
	Height int
}

type PersonsSliceDecrement []Persons
func (s PersonsSliceDecrement) Len() int { return len(s) }
func (s PersonsSliceDecrement) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s PersonsSliceDecrement) Less(i, j int) bool { return s[i].Age > s[j].Age }
func main() {
	arr1 := []Persons{
		Persons{10, 12},
		Persons{20, 12},
		Persons{9, 12},
		Persons{10, 12},
		Persons{11, 12},
	}
	sort.Sort(PersonsSliceDecrement(arr1))
	fmt.Println(arr1)
}

打印

[{20 12} {11 12} {10 12} {10 12} {9 12}]

按年紀從大到小，如果年紀相等的，按身高從小到到

type Persons struct {
	Age int
	Height int
}

type PersonsSliceDecrement []Persons
func (s PersonsSliceDecrement) Len() int { return len(s) }
func (s PersonsSliceDecrement) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s PersonsSliceDecrement) Less(i, j int) bool {
	if s[i].Age > s[j].Age {
		return true
	}
	if s[i].Age == s[j].Age && s[i].Height < s[j].Height {
		return true
	}
	return false
}

func main() {
	arr1 := []Persons{
		Persons{10, 120},
		Persons{20, 12},
		Persons{10, 110},
		Persons{10, 11},
		Persons{10, 100},
	}
	sort.Sort(PersonsSliceDecrement(arr1))
	fmt.Println(arr1)
}

打印

[{20 12} {10 11} {10 100} {10 110} {10 120}]

使用 sort.Stable 進行穩(wěn)定排序

sort.Sort 并不保證排序的穩(wěn)定性。如果有需要, 可以使用 sort.Stable ，用法就是將sort.Sort 替換為 sort.Stable

附：go根據(jù)結(jié)構(gòu)體中任意字段進行排序

附：根據(jù)結(jié)構(gòu)體中任意字段進行排序

Sort()

Reverse()

Less(i,j int) bool

Len() int

Swap(i,j int)

package main

import (
	"fmt"
	"sort"
)

type Student struct {
	Number   string
	Name     string
	Age      int
	IsWalker bool
	Weight   float32
}

type ByNumber []*Student

func (this ByNumber)Len() int  {
	return len(this)
}

func (this ByNumber)Less(i,j int) bool  {
	return this[i].Number<this[j].Number
}

func (this ByNumber)Swap(i,j int) {
	this[i],this[j] = this[j],this[i]
}

func (this ByNumber) String() string {
	const  format = "| %v |\t%v |\t%v |\t %v |\t %v |\t%v   |\n"
    fmt.Println("\t\t\t\t\t學(xué)生信息表")
    fmt.Println(" 序號\t學(xué)號 \t姓名\t   年齡\t  體重\t   是否走讀")
	for k,v:=range this{
		fmt.Printf(format,k+1,v.Number,v.Name,v.Age,v.Weight,v.IsWalker)
	}
	return ""
}

func main1() {
	sts:=[]*Student{
		&Student{Number: "003",Name: "張三"},
		&Student{Number: "004",Name: "張四"},
		&Student{Number: "001",Name: "張一"},
		&Student{Number: "002",Name: "張二"},
		&Student{Number: "000",Name: "張零"},
	}
	b:=ByNumber(sts)
	sort.Sort(b)
	fmt.Println(b)
	fmt.Println("反轉(zhuǎn)")
	sort.Sort(sort.Reverse(b))  //反轉(zhuǎn)的用法
	fmt.Println(b)


	//為結(jié)構(gòu)體內(nèi)的每一個字段都綁定一個排序的外殼，這種操作顯然不是很聰明
    //這時候使用組合來解決這個問題
}


type customSort struct {
	s []*Student
	less func(i,j *Student)  bool
}

func (this *customSort)Len() int {
	return len(this.s)
}

func (this *customSort)Swap(i,j int) {
	this.s[i],this.s[j] = this.s[j],this.s[i]
}

func (this *customSort)Less(i,j int) bool {
	return this.less(this.s[i],this.s[j])
}

func main()  {
	sts:=[]*Student{
		&Student{Number: "003",Name: "張三"},
		&Student{Number: "004",Name: "張四"},
		&Student{Number: "001",Name: "張一"},
		&Student{Number: "000",Name: "張二"},
		&Student{Number: "002",Name: "張二"},
	}

	c:=&customSort{
		s: sts,
		less: func(i, j *Student) bool {
			if i.Number != j.Number {    //可以指定多種排序規(guī)則
				return i.Number>j.Number
			}
			if i.Name!=j.Name{
				return i.Name<j.Name
			}
			return false
		},
	}

	/*
	package sort
	// 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.
	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)
	}
*/
	sort.Sort(c) //Sort方法中不只能放slice類型，還可以放結(jié)構(gòu)體類型,只要改類型 實現(xiàn) Sort接口
	fmt.Println(ByNumber(sts)) //單純的使用一下ByNumber中重寫是String()方法
}