Go Academy · Aula

Ordenação estável

Preserve a ordem de elementos iguais

Ordenação estável é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que é uma ordenação estável

Uma ordenação estável mantém os elementos iguais na ordem relativa original. Se dois registros forem considerados iguais, o que apareceu primeiro continua em primeiro lugar.

Por que isso é importante

A estabilidade é importante quando você ordena por um campo, mas quer preservar uma ordem anterior em caso de empate. Por exemplo, ordenar por cidade, mantendo as pessoas em ordem alfabética dentro de cada cidade.

sort.Slice não é estável

O sort.Slice comum não garante estabilidade. Elementos iguais podem ser reordenados. Para garantir a estabilidade, use sort.SliceStable.

sort.SliceStable

sort.SliceStable tem a mesma assinatura que sort.Slice, mas preserva a ordem dos elementos iguais.

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)
}

Observando a estabilidade com estruturas

Ordene as pessoas por idade. Com uma ordenação estável, as pessoas da mesma idade mantêm a ordem de entrada.

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 antes de Cara

No exemplo anterior, Ann e Cara têm 30 anos. Como Ann apareceu primeiro na entrada, uma ordenação estável mantém Ann antes de Cara no resultado.

Ordenação em várias passagens

A estabilidade permite ordenar em várias passagens. Ordene primeiro pela chave menos importante e depois pela mais importante. Cada passagem estável preserva a ordem anterior em caso de empate.

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

Para tipos que implementam sort.Interface, use sort.Stable em vez de sort.Sort para obter estabilidade.

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)
}

Custo da estabilidade

Ordenações estáveis podem usar um pouco mais de memória ou tempo do que as instáveis. Se você não precisar preservar a ordem dos elementos iguais, o sort.Slice simples será suficiente.

Quando escolher a ordenação estável

Escolha uma ordenação estável quando:

Os elementos tiverem uma ordem original significativa
Você ordenar em várias passagens por chaves diferentes
Os itens iguais não puderem ter a ordem alterada

Exemplo de verificação de ordenação estável

Dois itens com chaves de ordenação iguais aparecem na ordem de entrada, A e depois B. Uma ordenação estável garante que a saída mantenha A antes de 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ção rápida

Você ordena registros por cidade usando sort.SliceStable. Dois registros têm a mesma cidade. O que é garantido?

Recapitulação

A ordenação estável preserva a ordem dos elementos iguais:

sort.SliceStable para fatias
sort.Stable para tipos sort.Interface
Permite ordenar em várias passagens por chaves diferentes

Perguntas Frequentes

A aula “Ordenação estável” é grátis?

Sim — o texto completo de “Ordenação estável” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Ordenação estável”?

Preserve a ordem de elementos iguais Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Ordenação estável”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy