การจัดเรียงข้อมูล (Sorting) ถือเป็นหนึ่งในพื้นฐานสำคัญของการพัฒนาโปรแกรม เพราะไม่ว่าจะเป็นการค้นหา (Searching), การจัดอันดับ (Ranking) หรือการประมวลผลข้อมูล (Data Processing) ทุกกระบวนการล้วนต้องอาศัยอัลกอริทึมจัดเรียงที่ดีและเหมาะสมกับบริบทของงาน

ในบทความนี้ เราจะพาคุณมาศึกษาและเปรียบเทียบการทำงานของอัลกอริทึมจัดเรียงยอดนิยม ได้แก่ Bubble Sort, Merge Sort, Quick Sort รวมถึงการใช้งาน sort package ใน Go พร้อมตัวอย่างโค้ดจริงทั้งใน JavaScript และ Go เพื่อดูว่าภาษาใดจัดเรียงได้เร็วกว่า และอัลกอริทึมใดเหมาะกับระบบของคุณที่สุด 🔍

1. Bubble Sort

แนวคิด: อัลกอริทึมที่เข้าใจง่ายที่สุด ใช้หลักการ “เปรียบเทียบและสลับตำแหน่ง” ทีละคู่จนกว่าข้อมูลทั้งหมดจะเรียงลำดับสมบูรณ์

🔹 JavaScript: Bubble Sort

function bubbleSort(arr) {
  let n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    for (let j = 0; j < n - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      }
    }
  }
  return arr;
}

console.log(bubbleSort([5, 3, 8, 4, 2]));

ผลลัพธ์:

[2, 3, 4, 5, 8]

🔹 Go: Bubble Sort

package main

import "fmt"

func bubbleSort(arr []int) []int {
	n := len(arr)
	for i := 0; i < n-1; i++ {
		for j := 0; j < n-i-1; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}
	return arr
}

func main() {
	arr := []int{5, 3, 8, 4, 2}
	fmt.Println(bubbleSort(arr))
}

ผลลัพธ์:

[2 3 4 5 8]

สรุป: Bubble Sort เหมาะสำหรับสอนแนวคิดการเรียงลำดับ (Sorting Concept) แต่ไม่เหมาะกับระบบจริง เพราะมีความซับซ้อน O(n²) และทำงานช้าเมื่อข้อมูลมีจำนวนมาก

2. Merge Sort

แนวคิด: อัลกอริทึมแบบ “Divide and Conquer” แบ่งข้อมูลออกเป็นสองส่วน, จัดเรียงแต่ละส่วน, แล้วรวมกลับเข้าด้วยกันอย่างมีลำดับ

🔹 JavaScript: Merge Sort

function mergeSort(arr) {
  if (arr.length <= 1) return arr;

  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  let result = [], i = 0, j = 0;
  while (i < left.length && j < right.length) {
    if (left[i] < right[j]) result.push(left[i++]);
    else result.push(right[j++]);
  }
  return result.concat(left.slice(i)).concat(right.slice(j));
}

console.log(mergeSort([5, 3, 8, 4, 2]));

🔹 Go: Merge Sort

package main

import "fmt"

func mergeSort(arr []int) []int {
	if len(arr) <= 1 {
		return arr
	}
	mid := len(arr) / 2
	left := mergeSort(arr[:mid])
	right := mergeSort(arr[mid:])
	return merge(left, right)
}

func merge(left, right []int) []int {
	result := []int{}
	i, j := 0, 0
	for i < len(left) && j < len(right) {
		if left[i] < right[j] {
			result = append(result, left[i])
			i++
		} else {
			result = append(result, right[j])
			j++
		}
	}
	result = append(result, left[i:]...)
	result = append(result, right[j:]...)
	return result
}

func main() {
	arr := []int{5, 3, 8, 4, 2}
	fmt.Println(mergeSort(arr))
}

สรุป: Merge Sort มีความซับซ้อน O(n log n) เหมาะกับการจัดเรียงข้อมูลขนาดใหญ่ เพราะใช้หน่วยความจำเพิ่มเพื่อแบ่งย่อยและรวมผลลัพธ์

3. Quick Sort

แนวคิด: เป็นอัลกอริทึมแบบ “Divide and Conquer” เช่นเดียวกับ Merge Sort แต่ใช้การเลือก “Pivot” เพื่อแบ่งข้อมูลออกเป็นกลุ่มที่ “น้อยกว่า” และ “มากกว่า” แล้วจัดเรียงแต่ละส่วนแยกกัน

🔹 JavaScript: Quick Sort

function quickSort(arr) {
  if (arr.length <= 1) return arr;
  const pivot = arr[arr.length - 1];
  const left = arr.filter(x => x < pivot);
  const right = arr.filter(x => x > pivot);
  return [...quickSort(left), pivot, ...quickSort(right)];
}

console.log(quickSort([5, 3, 8, 4, 2]));

🔹 Go: Quick Sort

package main

import "fmt"

func quickSort(arr []int) []int {
	if len(arr) <= 1 {
		return arr
	}
	pivot := arr[len(arr)-1]
	left, right := []int{}, []int{}
	for _, v := range arr[:len(arr)-1] {
		if v < pivot {
			left = append(left, v)
		} else {
			right = append(right, v)
		}
	}
	left = quickSort(left)
	right = quickSort(right)
	return append(append(left, pivot), right...)
}

func main() {
	arr := []int{5, 3, 8, 4, 2}
	fmt.Println(quickSort(arr))
}

สรุป: Quick Sort โดยทั่วไปทำงานเร็วกว่า Merge Sort ในกรณีทั่วไป (O(n log n)) แต่มี Worst Case ที่อาจช้าถึง O(n²) หากเลือก Pivot ไม่เหมาะสม

4. การใช้ sort Package ใน Go

ภาษา Go มี package มาตรฐาน sort ที่ช่วยให้สามารถจัดเรียงข้อมูลได้รวดเร็วโดยไม่ต้องเขียนอัลกอริทึมเอง

package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := []int{5, 3, 8, 4, 2}
	sort.Ints(nums)
	fmt.Println(nums)
}

ผลลัพธ์:

[2 3 4 5 8]

ข้อดี:
✅ ความเร็วสูง (optimized O(n log n))
✅ ใช้งานง่าย เหมาะกับระบบ Production
✅ รองรับ sort.Strings, sort.Slice, sort.Float64s

5. สรุปเปรียบเทียบอัลกอริทึม

สรุปและคำแนะนำ

• 💡 JavaScript เหมาะกับการทดลองอัลกอริทึมและการใช้งานฝั่ง Frontend
• ⚙️ Go เหมาะกับระบบ Production-Level ที่ต้องการความเร็วสูง เช่น API, Backend Processing หรือ Data Pipelines
• 🧠 ใช้ sort package ใน Go เพื่อให้ได้ performance สูงสุด
• 🚀 หากคุณอยู่ฝั่ง JavaScript ให้เลือกใช้ Quick Sort หรือ Merge Sort สำหรับการจัดเรียงข้อมูลจำนวนมาก

ตอนต่อไป

ใน EP.36 ของซีรีส์ JS2GO เราจะพาคุณไปเรียนรู้หัวข้อ “การทำ Searching Algorithms ใน Go และ JavaScript” เพื่อเข้าใจเทคนิคการค้นหาข้อมูลอย่างมีประสิทธิภาพ เช่น Linear Search, Binary Search, และ Map-based Lookup พร้อมแนวทางการเลือกใช้ให้เหมาะกับระบบจริง 🔍

อ่านบทความ Series อื่นๆ

• Golang The Series
• JS2GO
• 10 Ep ที่จะให้คุณเป็นมือโปร Tailwind CSS ในชั่วข้ามคืน

🔵 Facebook: https://www.facebook.com/superdev.academy.th

🔴 YouTube : Superdev Academy

📸 Instagram: Superdev Academy

🎬 TikTok: https://www.tiktok.com/@superdevacademy?lang=th-TH

🌐 Website: https://www.superdevacademy.com/