Go Academy · Lezione

Ordinamento stabile

Preservare l'ordine degli elementi equivalenti

Ordinamento stabile è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Che cos'è l'ordinamento stabile

Un ordinamento stabile mantiene l'ordine relativo originale degli elementi uguali. Se due record risultano uguali nel confronto, quello che compariva prima rimane prima.

Perché è importante

La stabilità è importante quando ordina per un campo, ma vuole preservare un ordine precedente in caso di parità. Per esempio, può ordinare per città mantenendo l'ordine alfabetico delle persone all'interno di ogni città.

sort.Slice non è stabile

Il normale sort.Slice non garantisce la stabilità. Gli elementi uguali possono essere riordinati. Per garantire la stabilità, utilizzi sort.SliceStable.

sort.SliceStable

sort.SliceStable ha la stessa firma di sort.Slice, ma preserva l'ordine degli elementi uguali.

package main

import (
	"fmt"
	"sort"
)

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

Vedere la stabilità con le struct

Ordini le persone per età. Con un ordinamento stabile, le persone della stessa età mantengono l'ordine di input.

package main

import (
	"fmt"
	"sort"
)

type Person struct {
	Name string
	Age  int
}

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

Ann prima di Cara

Nell'esempio precedente, Ann e Cara hanno entrambe 30 anni. Poiché Ann compariva prima nell'input, un ordinamento stabile mantiene Ann prima di Cara nel risultato.

Ordinamento in più passaggi

La stabilità consente di ordinare in più passaggi. Ordini prima per la chiave meno importante e poi per quella più importante. Ogni passaggio stabile preserva l'ordine precedente in caso di parità.

package main

import (
	"fmt"
	"sort"
)

type Rec struct {
	City string
	Name string
}

func main() {
	r := []Rec{{"Rome", "Zoe"}, {"Oslo", "Ann"}, {"Rome", "Ann"}}
	sort.SliceStable(r, func(i, j int) bool { return r[i].Name < r[j].Name })
	sort.SliceStable(r, func(i, j int) bool { return r[i].City < r[j].City })
	fmt.Println(r)
}

sort.Stable

Per i tipi che implementano sort.Interface, utilizzi sort.Stable invece di sort.Sort per ottenere la stabilità.

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{"bb", "cc", "a"}
	sort.Stable(ByLen(w))
	fmt.Println(w)
}

Il costo della stabilità

Gli ordinamenti stabili possono utilizzare leggermente più memoria o tempo rispetto a quelli non stabili. Se non deve preservare l'ordine degli elementi uguali, il normale sort.Slice è sufficiente.

Quando scegliere l'ordinamento stabile

Scelga un ordinamento stabile quando:

Gli elementi hanno un ordine originale significativo
Esegue più passaggi di ordinamento con chiavi diverse
Gli elementi uguali non devono essere rimescolati

Esempio di verifica dell'ordinamento stabile

Due elementi con chiavi di ordinamento uguali compaiono nell'ordine di input, prima A e poi B. Un ordinamento stabile garantisce che nell'output A rimanga prima di B.

package main

import (
	"fmt"
	"sort"
)

func main() {
	type T struct{ Key, Tag int }
	ts := []T{{1, 100}, {1, 200}, {0, 300}}
	sort.SliceStable(ts, func(i, j int) bool { return ts[i].Key < ts[j].Key })
	fmt.Println(ts)
}

Verifica rapida

Ordina i record per città usando sort.SliceStable. Due record hanno la stessa città. Che cosa è garantito?

Riepilogo

L'ordinamento stabile preserva l'ordine degli elementi uguali:

sort.SliceStable per gli slice
sort.Stable per i tipi sort.Interface
Consente l'ordinamento in più passaggi con chiavi diverse

Domande Frequenti

La lezione «Ordinamento stabile» è gratuita?

Sì — il testo completo di «Ordinamento stabile» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Ordinamento stabile»?

Preservare l'ordine degli elementi equivalenti Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Ordinamento stabile»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy