Go Academy · Pelajaran

Pengurutan Stabil

Pertahankan urutan elemen yang sama

Pengurutan Stabil adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Go Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Go Academy mencakup 4 pelajaran total.

Apa Itu Pengurutan Stabil

Pengurutan stabil mempertahankan urutan relatif asli elemen-elemen yang sama. Jika dua rekaman dianggap sama saat dibandingkan, rekaman yang muncul lebih dahulu tetap berada lebih dahulu.

Mengapa Ini Penting

Stabilitas penting ketika Anda mengurutkan berdasarkan satu bidang, tetapi ingin mempertahankan urutan sebelumnya untuk nilai yang sama. Misalnya, urutkan berdasarkan kota sambil mempertahankan urutan alfabetis orang-orang di setiap kota.

sort.Slice Tidak Stabil

sort.Slice biasa tidak menjamin stabilitas. Elemen-elemen yang sama dapat diurutkan ulang. Untuk stabilitas yang terjamin, gunakan sort.SliceStable.

sort.SliceStable

sort.SliceStable memiliki tanda tangan yang sama dengan sort.Slice, tetapi mempertahankan urutan elemen-elemen yang sama.

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

Melihat Stabilitas dengan Struktur

Urutkan orang berdasarkan usia. Dengan pengurutan stabil, orang-orang dengan usia yang sama mempertahankan urutan masukannya.

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 Sebelum Cara

Pada contoh sebelumnya, Ann dan Cara sama-sama berusia 30 tahun. Karena Ann muncul lebih dahulu dalam masukan, pengurutan stabil mempertahankan Ann sebelum Cara dalam hasilnya.

Pengurutan Bertahap

Stabilitas memungkinkan pengurutan dalam beberapa tahap. Urutkan berdasarkan kunci yang paling tidak penting terlebih dahulu, lalu berdasarkan kunci yang paling penting. Setiap tahap stabil mempertahankan urutan sebelumnya untuk nilai yang sama.

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

Untuk tipe yang mengimplementasikan sort.Interface, gunakan sort.Stable, bukan sort.Sort, untuk mendapatkan stabilitas.

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

Biaya Stabilitas

Pengurutan stabil mungkin menggunakan sedikit lebih banyak memori atau waktu daripada pengurutan tidak stabil. Jika Anda tidak perlu mempertahankan urutan elemen yang sama, sort.Slice biasa sudah memadai.

Kapan Memilih Pengurutan Stabil

Pilih pengurutan stabil ketika:

Elemen memiliki urutan asli yang bermakna
Anda mengurutkan dalam beberapa tahap berdasarkan kunci yang berbeda
Item yang sama tidak boleh diacak

Contoh Pemeriksaan Pengurutan Stabil

Dua item dengan kunci pengurutan yang sama muncul dalam urutan masukan, yaitu A kemudian B. Pengurutan stabil menjamin keluaran tetap menempatkan A sebelum 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)
}

Pemeriksaan Singkat

Anda mengurutkan rekaman berdasarkan kota menggunakan sort.SliceStable. Dua rekaman memiliki kota yang sama. Apa yang dijamin?

Ringkasan

Pengurutan stabil mempertahankan urutan elemen yang sama:

sort.SliceStable untuk slice
sort.Stable untuk jenis sort.Interface
Memungkinkan pengurutan bertahap berdasarkan kunci yang berbeda

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengurutan Stabil” gratis?

Ya — teks lengkap “Pengurutan Stabil” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Go Academy, upgrade ke CoddyKit PRO. Kursus Go Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pengurutan Stabil”?

Pertahankan urutan elemen yang sama Kamu berlatih Go Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Go Academy?

Tidak diperlukan pengalaman sebelumnya. Go Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pengurutan Stabil” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Go Academy ini?

Ya. Setiap pelajaran Go Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Go Academy