Selection Sort: เรียนรู้การจัดเรียงข้อมูลกับ Groovy**

 

ในโลกของการเขียนโปรแกรม เรามักจะเจอกับปัญหาการจัดเรียงข้อมูล (Sorting) ซึ่งมีหลายอัลกอริธึมที่ช่วยให้เราสามารถจัดเรียงข้อมูลได้อย่างมีประสิทธิภาพ หนึ่งในนั้นคือ “Selection Sort” ซึ่งในบทความนี้เราจะไปทำความรู้จักกับอัลกอริธึมนี้ พร้อมทั้งยกตัวอย่างในการเขียนโปรแกรมด้วยภาษา Groovy ให้เข้าใจได้ง่าย

 

Selection Sort คืออะไร?

Selection Sort เป็นอัลกอริธึมการจัดเรียงที่ทำงานโดยการค้นหาตำแหน่งที่น้อยที่สุดในลิสต์ (array) จากนั้นนำไปแลกเปลี่ยนกับตำแหน่งที่ต้องการจัดเรียง โดยจะทำแบบนี้สำหรับทุกตำแหน่งในลิสต์ ความสนุกของ Selection Sort คือความเรียบง่ายในการทำตามกระบวนการ และในขณะเดียวกันก็สามารถอธิบายได้อย่างชัดเจนว่าเกิดอะไรขึ้นในแต่ละขั้นตอน

 

วิธีการทำงานของ Selection Sort

1. เริ่มต้นที่ตำแหน่งแรกในลิสต์

2. ค้นหาค่าที่เล็กที่สุดจากตำแหน่งปัจจุบันถึงตำแหน่งสุดท้าย

3. แลกเปลี่ยนค่าที่เล็กที่สุดกับค่าที่อยู่ที่ตำแหน่งปัจจุบัน

4. ย้ายไปยังตำแหน่งถัดไปและทำซ้ำกระบวนการจนถึงตำแหน่งสุดท้าย

 

ตัวอย่างโค้ดใน Groovy

 def selectionSort(arr) {
    int n = arr.size()
    for (int i = 0; i < n-1; i++) {
        int minIndex = i
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j
            }
        }
        // Swap the found minimum element with the first element
        if (minIndex != i) {
            def temp = arr[i]
            arr[i] = arr[minIndex]
            arr[minIndex] = temp
        }
    }
    return arr
}

// ทดลองเรียกใช้ฟังก์ชัน
def numbers = [64, 25, 12, 22, 11]
println("Before sorting: $numbers")
println("After sorting: ${selectionSort(numbers)}")

จากโค้ดด้านบน เราใช้ฟังก์ชัน `selectionSort` ในการจัดเรียงลิสต์ของตัวเลข การทำงานของโค้ดจะแบ่งออกเป็นการวนลูปสองระดับ ซึ่งลูปภายนอกจะทำเพื่อเลือกตำแหน่งในลิสต์และลูปภายในจะทำการค้นหาค่าที่น้อยที่สุดที่อยู่ในตำแหน่งถัดไป ผลลัพธ์จะแสดงผลก่อนและหลังการจัดเรียงข้อมูล

 

Use cases ในโลกจริง

อัลกอริธึม Selection Sort มักจะถูกใช้ในสถานการณ์ที่ข้อมูลมีปริมาณน้อยหรือในกรณีที่ไม่ต้องการพึ่งพาความซับซ้อนของอัลกอริธึมที่มีประสิทธิภาพมากกว่า ตัวอย่างเช่น:

- การจัดเรียงรายการสินค้าในหน้าจอ UI: เมื่อแสดงรายการสินค้าบนเว็บไซต์ที่มีจำนวนสินค้าน้อย อาจไม่จำเป็นต้องใช้อัลกอริธึมที่ซับซ้อน เช่น Quick Sort หรือ Merge Sort - การศึกษาหรือสอนแนวคิดพื้นฐานเกี่ยวกับ Sorting: Selection Sort เป็นหนึ่งในอัลกอริธึมที่เหมาะสำหรับการสอนให้ผู้เรียนเข้าใจแนวคิดพื้นฐานเกี่ยวกับการจัดเรียง ซึ่งเหมาะสำหรับนักเรียนในระดับเริ่มต้น

 

Complexity Analysis

- เวลา (Time Complexity):

- Best Case: O(n^2)

- Average Case: O(n^2)

- Worst Case: O(n^2)

จากที่กล่าวมา เราจะเห็นว่าเวลาที่ใช้ในการจัดเรียงไม่ขึ้นกับการกระจายตัวของข้อมูล ซึ่งทำให้ Selection Sort ไม่เหมาะกับขนาดข้อมูลที่ใหญ่เกินไป

- พื้นที่ (Space Complexity):

- O(1): อัลกอริธึมนี้ใช้พื้นที่เพิ่มเติมน้อยมาก สิ่งนี้ทำให้มันเป็นตัวเลือกที่ดีเมื่อพื้นที่ในหน่วยความจำมีค่ามาก

 

ข้อดีข้อเสียของ Selection Sort

ข้อดี

: 1. ใช้งานง่าย: โค้ดอ่านง่ายและเข้าใจง่าย เหมาะสำหรับผู้เริ่มต้น 2. พื้นที่จัดเก็บต่ำ: เนื่องจากไม่จำเป็นต้องใช้ข้อมูลสำรองมากนัก

ข้อเสีย

: 1. ประสิทธิภาพต่ำ: ไม่เหมาะสำหรับข้อมูลใหญ่ เพราะมี Time Complexity สูง 2. การค้นหาข้อมูลที่ไม่จำเป็น: แม้ว่าอัลกอริธึมนี้จะเรียบง่ายแต่ก็มีการค้นหาข้อมูลที่ยังไม่จำเป็น

 

บทสรุป

Selection Sort เป็นอัลกอริธึมการจัดเรียงที่ง่ายต่อการเขียนและเข้าใจ เหมาะสำหรับใช้ในสถานการณ์ที่ข้อมูลมีขนาดเล็กหรือในการสอนให้ผู้เรียนเข้าใจแนวคิดพื้นฐานเรื่องการจัดเรียง หากคุณสนใจที่จะพัฒนาทักษะการเขียนโปรแกรมของคุณให้ดียิ่งขึ้น ไม่ว่าจะเป็นการเรียนรู้เกี่ยวกับอัลกอริธึมในสายงานต่างๆ การเขียนโปรแกรมหรือการพัฒนาเว็บไซต์ EPT (Expert Programming Tutor) ยินดีต้อนรับคุณเข้ามาเรียนรู้และพัฒนาความรู้กัน!

เรียนรู้และพัฒนาไปด้วยกันกับ EPT ที่นี่ที่เดียว!

 

 

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง