Go Academy · บทเรียน

การเรียงลำดับแบบคงเสถียรภาพ

รักษาลำดับขององค์ประกอบที่เท่ากัน

การเรียงลำดับแบบคงเสถียรภาพ เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

การเรียงลำดับแบบคงเสถียรภาพคืออะไร

การเรียงลำดับแบบคงเสถียรภาพจะรักษาลำดับสัมพัทธ์เดิมขององค์ประกอบที่มีค่าเท่ากัน หากระเบียนสองรายการมีผลการเปรียบเทียบเท่ากัน รายการที่มาก่อนจะยังคงอยู่ก่อน

เหตุใดจึงสำคัญ

ความคงเสถียรภาพมีความสำคัญเมื่อคุณเรียงตามฟิลด์หนึ่ง แต่ต้องการรักษาลำดับก่อนหน้าไว้สำหรับค่าที่เท่ากัน ตัวอย่างเช่น เรียงตามเมืองโดยยังคงเรียงชื่อบุคคลตามตัวอักษรภายในแต่ละเมือง

sort.Slice ไม่คงเสถียรภาพ

sort.Slice ทั่วไปไม่รับประกันความคงเสถียรภาพ องค์ประกอบที่เท่ากันอาจถูกสลับลำดับ หากต้องการรับประกันความคงเสถียรภาพ ให้ใช้ sort.SliceStable

sort.SliceStable

sort.SliceStable มีลายเซ็นเหมือนกับ sort.Slice แต่จะรักษาลำดับขององค์ประกอบที่เท่ากันไว้

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

ดูความคงเสถียรภาพกับโครงสร้าง

เรียงบุคคลตามอายุ เมื่อใช้การเรียงลำดับแบบคงเสถียรภาพ บุคคลที่มีอายุเท่ากันจะยังคงอยู่ตามลำดับในข้อมูลนำเข้า

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 อยู่ก่อน Cara

ในตัวอย่างก่อนหน้า Ann และ Cara ต่างก็มีอายุ 30 ปี เนื่องจาก Ann ปรากฏในข้อมูลนำเข้าก่อน การเรียงลำดับแบบคงเสถียรภาพจึงทำให้ Ann อยู่ก่อน Cara ในผลลัพธ์

การเรียงลำดับหลายรอบ

ความคงเสถียรภาพทำให้สามารถเรียงลำดับเป็นรอบ ๆ ได้ ให้เรียงตามคีย์ที่สำคัญน้อยกว่าก่อน แล้วจึงเรียงตามคีย์ที่สำคัญที่สุด การเรียงแต่ละรอบแบบคงเสถียรภาพจะรักษาลำดับก่อนหน้าไว้เมื่อค่าเท่ากัน

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

สำหรับชนิดที่ใช้งาน sort.Interface ให้ใช้ sort.Stable แทน sort.Sort เพื่อให้การเรียงลำดับคงเสถียรภาพ

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

ต้นทุนของความคงเสถียรภาพ

การเรียงลำดับแบบคงเสถียรภาพอาจใช้หน่วยความจำหรือเวลามากกว่าการเรียงลำดับแบบไม่คงเสถียรภาพเล็กน้อย หากคุณไม่จำเป็นต้องรักษาลำดับขององค์ประกอบที่เท่ากัน การใช้ sort.Slice ปกติก็เพียงพอ

เมื่อใดควรเลือกแบบคงเสถียรภาพ

เลือกการเรียงลำดับแบบเสถียรเมื่อ:

องค์ประกอบมีลำดับเดิมที่มีความหมาย
คุณเรียงลำดับหลายรอบด้วยคีย์ต่างกัน
รายการที่เท่ากันต้องไม่ถูกสลับลำดับ

ตัวอย่างการตรวจสอบการเรียงลำดับแบบเสถียร

รายการสองรายการที่มีคีย์การเรียงลำดับเท่ากันปรากฏในอินพุตตามลำดับ A แล้ว B การเรียงลำดับแบบเสถียรรับประกันว่าผลลัพธ์จะยังคงให้ A อยู่ก่อน 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)
}

ตรวจสอบความเข้าใจอย่างรวดเร็ว

คุณเรียงลำดับระเบียนตามเมืองโดยใช้ sort.SliceStable ระเบียนสองรายการมีเมืองเดียวกัน สิ่งใดได้รับการรับประกัน

สรุป

การเรียงลำดับแบบเสถียรจะรักษาลำดับขององค์ประกอบที่เท่ากันไว้:

sort.SliceStable สำหรับสไลซ์
sort.Stable สำหรับชนิดที่เป็น sort.Interface
ทำให้เรียงลำดับหลายรอบด้วยคีย์ต่างกันได้

คำถามที่พบบ่อย

บทเรียน “การเรียงลำดับแบบคงเสถียรภาพ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การเรียงลำดับแบบคงเสถียรภาพ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การเรียงลำดับแบบคงเสถียรภาพ”

รักษาลำดับขององค์ประกอบที่เท่ากัน คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การเรียงลำดับแบบคงเสถียรภาพ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม

ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Go Academy