Go Academy · Lección

Ordenación estable

Conserve el orden de los elementos iguales

Ordenación estable es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Qué es la ordenación estable

Una ordenación estable conserva el orden relativo original de los elementos iguales. Si dos registros se consideran iguales, el que aparecía primero sigue apareciendo primero.

Por qué es importante

La estabilidad es importante cuando ordena por un campo, pero quiere conservar un orden anterior en caso de empate. Por ejemplo, puede ordenar por ciudad y mantener a las personas en orden alfabético dentro de cada ciudad.

sort.Slice no es estable

La función sort.Slice normal no garantiza la estabilidad. Los elementos iguales pueden cambiar de orden. Para garantizar la estabilidad, use sort.SliceStable.

sort.SliceStable

sort.SliceStable tiene la misma firma que sort.Slice, pero conserva el orden de los elementos iguales.

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

Observar la estabilidad con structs

Ordene las personas por edad. Con una ordenación estable, las personas de la misma edad conservan el orden que tenían en la 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 que Cara

En el ejemplo anterior, Ann y Cara tienen 30 años. Como Ann aparecía primero en la entrada, una ordenación estable mantiene a Ann antes que Cara en el resultado.

Ordenación en varias pasadas

La estabilidad permite ordenar en varias pasadas. Ordene primero por la clave menos importante y después por la más importante. Cada pasada estable conserva el orden anterior en 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 los tipos que implementan sort.Interface, use sort.Stable en lugar de sort.Sort para obtener estabilidad.

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

Coste de la estabilidad

Las ordenaciones estables pueden usar un poco más de memoria o tiempo que las inestables. Si no necesita conservar el orden de los elementos iguales, sort.Slice es suficiente.

Cuándo elegir una ordenación estable

Elija una ordenación estable cuando:

Los elementos tengan un orden original significativo
Ordene en varias pasadas usando distintas claves
Los elementos iguales no deban cambiar de posición

Ejemplo de comprobación de estabilidad

Dos elementos con la misma clave de ordenación aparecen en la entrada en el orden A y después B. Una ordenación estable garantiza que la salida mantenga A antes que 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)
}

Comprobación rápida

Ordena registros por ciudad usando sort.SliceStable. Dos registros comparten la misma ciudad. ¿Qué se garantiza?

Resumen

La ordenación estable conserva el orden de los elementos iguales:

sort.SliceStable para slices
sort.Stable para tipos sort.Interface
Permite ordenar en varias pasadas usando distintas claves

Preguntas frecuentes

¿La lección «Ordenación estable» es gratis?

Sí — el texto completo de «Ordenación estable» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Ordenación estable»?

Conserve el orden de los elementos iguales Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Ordenación estable»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy