Go Academy · Lekcja

Niestandardowe porządki sortowania

Definiuj funkcje porównujące

Niestandardowe porządki sortowania to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Poza kolejnością domyślną

Domyślne sortowanie odbywa się rosnąco. Rzeczywiste dane wymagają jednak niestandardowych reguł: sortowania według długości, wielu pól lub obliczanej wartości.

To właśnie w funkcji porównującej wyraża się dowolną potrzebną regułę.

Funkcja less

Funkcja porównująca dla sort.Slice ma sygnaturę func(i, j int) bool. Zwraca true, gdy element i powinien znajdować się przed elementem j.

package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := []int{4, 1, 3}
	less := func(i, j int) bool { return nums[i] < nums[j] }
	sort.Slice(nums, less)
	fmt.Println(nums)
}

Sortowanie według długości napisu

Zamiast porządku alfabetycznego porównaj wynik len() dla każdego napisu, aby uporządkować je według długości.

package main

import (
	"fmt"
	"sort"
)

func main() {
	words := []string{"pear", "fig", "banana"}
	sort.Slice(words, func(i, j int) bool {
		return len(words[i]) < len(words[j])
	})
	fmt.Println(words)
}

Sortowanie struktur według pola

Do porównania można wybrać dowolne pole struktury. Tutaj sortujemy produkty według ceny.

package main

import (
	"fmt"
	"sort"
)

type Product struct {
	Name  string
	Price int
}

func main() {
	items := []Product{{"Pen", 3}, {"Book", 12}, {"Cup", 7}}
	sort.Slice(items, func(i, j int) bool {
		return items[i].Price < items[j].Price
	})
	fmt.Println(items)
}

Sortowanie według wielu pól

Aby rozstrzygać remisy, porównuj drugie pole, gdy pierwsze ma taką samą wartość. Sortuj według wieku, a następnie według imienia.

package main

import (
	"fmt"
	"sort"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	p := []Person{{"Zoe", 30}, {"Ann", 30}, {"Bob", 25}}
	sort.Slice(p, func(i, j int) bool {
		if p[i].Age != p[j].Age {
			return p[i].Age < p[j].Age
		}
		return p[i].Name < p[j].Name
	})
	fmt.Println(p)
}

Odwracanie za pomocą sort.Reverse

sort.Reverse opakowuje interfejs sort.Interface, aby odwrócić jego kolejność. Współpracuje z funkcjami pomocniczymi, takimi jak sort.IntSlice.

package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := []int{1, 4, 2, 3}
	sort.Sort(sort.Reverse(sort.IntSlice(nums)))
	fmt.Println(nums)
}

Interfejs sort.Interface

Aby uzyskać pełną kontrolę, zaimplementuj sort.Interface: trzy metody Len(), Less(i, j int) bool i Swap(i, j int).

package main

import (
	"fmt"
	"sort"
)

type ByLen []string

func (s ByLen) Len() int           { return len(s) }
func (s ByLen) Less(i, j int) bool { return len(s[i]) < len(s[j]) }
func (s ByLen) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func main() {
	w := []string{"ccc", "a", "bb"}
	sort.Sort(ByLen(w))
	fmt.Println(w)
}

Sortowanie według obliczanej wartości

Porównanie może korzystać z dowolnego wyrażenia. Posortuj liczby według ich bezwzględnej odległości od zera.

package main

import (
	"fmt"
	"sort"
)

func abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}

func main() {
	nums := []int{-5, 2, -1, 3}
	sort.Slice(nums, func(i, j int) bool {
		return abs(nums[i]) < abs(nums[j])
	})
	fmt.Println(nums)
}

Sortowanie bez uwzględniania wielkości liter

Użyj strings.ToLower wewnątrz porównania, aby podczas porządkowania napisów ignorować wielkość liter.

package main

import (
	"fmt"
	"sort"
	"strings"
)

func main() {
	w := []string{"banana", "Apple", "cherry"}
	sort.Slice(w, func(i, j int) bool {
		return strings.ToLower(w[i]) < strings.ToLower(w[j])
	})
	fmt.Println(w)
}

Slice kontra interfejs

Istnieją dwa sposoby dostosowania kolejności:

sort.Slice - szybka, wbudowana funkcja less
sort.Interface - wielokrotnie używany nazwany typ z trzema metodami

Do jednorazowego sortowania preferuj sort.Slice.

Zachowuj czystość porównań

Funkcja porównująca powinna tylko odczytywać elementy i zwracać wartość boolowską. Nie może modyfikować wycinka ani wywoływać efektów ubocznych, ponieważ sortowanie może wtedy działać w nieprzewidywalny sposób.

Szybkie sprawdzenie

Chcą Państwo sortować osoby według wieku, a w przypadku równego wieku — według imienia. Jakiej techniki należy użyć?

Podsumowanie

Można definiować dowolną kolejność sortowania:

Funkcja less wyraża Państwa regułę
Sortowanie według wielu pól porównuje drugie pole w przypadku remisu
sort.Reverse odwraca kolejność, a sort.Interface udostępnia wielokrotnie używane typy

Często zadawane pytania

Czy lekcja „Niestandardowe porządki sortowania” jest bezpłatna?

Tak — pełny tekst „Niestandardowe porządki sortowania” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Niestandardowe porządki sortowania”?

Definiuj funkcje porównujące Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Niestandardowe porządki sortowania”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy