วิชาโครงสร้างข้อมูล

1.  การจัดเรียงข้อมูล (Sorting)
วิชา COSC2202
โครงสร้างข้อมูล (Data Structure)

2. การจัดเรียงข้อมูล (Sorting)
 การจัดเรียงลำาดับ (Sorting) หมายถึง การจัดเรียงข้อมูลให้
เรียงลำาดับตามเงื่อนไขที่กำาหนดไว้ โดยอาจเรียงจากน้อยไป
มาก หรือค่ามากไปน้อยก็ได้ การเรียงลำาดับข้อมูลในระบบ
คอมพิวเตอร์ จะแบ่งเป็น 2 ลักษณะใหญ่ ๆ คือ
1. การเรียงลำาดับข้อมูลภายใน (Internal sorting)
 ใช้กับข้อมูลที่มีจำานวนไม่ใหญ่กว่าเนื้อที่ในหน่วยความจำา (main
memory)
 ไม่ต้องใช้หน่วยความจำาสำารอง เช่น ดิสก์, เทป เป็นต้น
2. การเรียงลำาดับข้อมูลภายนอก (External sorting)
 ใช้กับข้อมูลที่มีจำานวนใหญ่เกินกว่าที่จะเก็บลงในหน่วยความจำาได้

3. ประเภทของการเรียงลำาดับข้อมูล
หยิบแทรก เลือกข้อมูลที่
ต้องการมา
สลับที่ข้อมูลที่ไม่
ถูกตำาแหน่ง
Sort Order
1. Ascending Order เรียง
จากน้อย --> มาก

4. Insertion Sort
 การจัดเรียงแบบแทรก คือ การเรียงข้อมูลโดยนำา
ข้อมูลที่จะทำาการจัดเรียงนั้นๆ ไปจัดเรียงทีละตัว
โดยการแทรกตัวที่จะเรียงไว้ในตำาแหน่งที่เหมาะสม
ของข้อมูลที่มีการจัดเรียงเรียบร้อยแล้ว ณ ตำาแหน่ง
ที่ถูกต้อง

5. Insertion Sort
ขั้นตอน
 เปรียบเทียบค่ากับตำาแหน่งถัด
ไปแทน
 สลับตำาแหน่งให้อยู่ในตำาแหน่ง
ที่เหมาะสม

6. Shell Sort
 การจัดเรียงแบบเชลล์ เป็นการจัดเรียงที่อาศัยเทคนิค
การแบ่งข้อมูลออกเป็นกลุ่มย่อยหลายๆ กลุ่ม แล้วจัด
เรียงข้อมูลในกลุ่มย่อยๆ นั้น หลังจากนั้นก็ให้รวม
กลุ่มย่อยๆ ให้ใหญ่ขึ้นเรื่อยๆ ขั้นสุดท้ายให้จัดเรียง
ข้อมูลทั้งหมดนั้นอีกครั้ง

7. Shell Sort
ตัวอย่าง กำาหนด Segment เมื่อ K=3

8. Shell Sort
ขั้นตอน
 โดยทั่วไปการเลือกค่า K ตัวแรกมักจะเลือกใช้ค่า
เท่ากับครึ่งหนึ่งของข้อมูล เช่น ข้อมูลมี 10 ตัว K =
n/2 = 10/2 = 5
 เรียงข้อมูลทุกตัวให้เสร็จสิ้น แล้วกำาหนดค่า K ใหม่
(โดยทั่วไปจะเป็นครึ่งหนึ่งของค่า K ตัวแรก เช่น K1
= 5; K2 = 5/2 = 2)
 ถ้า K > 1 ให้ทำาซำ้า จนกระทั่งเหลือข้อมูลกลุ่มเดียว

9. Shell Sort
วอย่างการทำางานในแต่ละรอบของ K

10. Shell Sort

11. Shell Sort

12. Selection Sort
 การจัดเรียงแบบเลือก เป็นวิธีการเรียงข้อมูลโดยจะ
เริ่มต้นค้นหาข้อมูลตัวที่น้อยที่สุดจากข้อมูลที่มีอยู่
ทั้งหมด แล้วสลับที่ข้อมูลกับตัวแรก แล้วกลับไปหา
ข้อมูลตัวที่น้อยที่สุดในกองต่อไปสลับที่กับข้อมูล
จนกว่าจะหมดกอง

13. Selection Sort
ขั้นตอน
 ค้นหาตัวเลขที่มีค่าน้อย/มาก
ที่สุดตั้งแต่ตัวแรกไปจนถึงตัว
สุดท้าย
 สลับตำาแหน่งตัวเลขที่มีค่า
น้อย/มากที่สุด

14. Heap Sort

15. Heap Sort

16. Bubble Sort
 การจัดเรียงแบบบับเบิล เป็นการจัดเรียงโดยการ
เปรียบเทียบค่า 2 ค่าที่ติดกัน ทำาต่อเนื่องกันไป
เรื่อยๆ

17. Bubble Sort

18. Quick Sort
 การจัดเรียงแบบควิกซ์ ใช้หลักการ divide-and-
conquer อาศัยการจัดแบ่งข้อมูลทั้งหมดออกเป็น 2
กลุ่ม โดยกลุ่มแรกจะเป็นกลุ่มของข้อมูลที่มีค่าน้อย
กว่าค่ากลางที่กำาหนด และส่วนที่สองเป็นกลุ่มของ
ข้อมูลที่มีค่ามากกว่าค่ากลางที่กำาหนด หลังจากนั้น
แบ่งข้อมูลแต่ละส่วนออกเป็น 2 ส่วนเช่นเดิม แบ่งไป
เรื่อยๆจนไม่สามารถแบ่งได้ก็จะได้ข้อมูลที่เรียงกัน

19. Quick Sort
ขั้นตอน
 มีการเลือกข้อมูลตัวหนึ่ง
เรียกว่า Pivot ที่ใช้เป็นตัว
แบ่งแยกชุดข้อมูลที่เรามี
ออกเป็นส่วน คือ ข้อมูลที่มี
ค่าน้อยกว่า Pivot และ
ข้อมูลที่มีค่ามากกว่า Pivot
 แบ่งข้อมูลไปเรื่อยๆ
 เรียงข้อมูลแต่ละส่วนย่อยๆ
>
>
>

20. Quick Sort
การแบ่งส่วนข้อมูลใช้หลักการ Picking the pivot คือการ
กำาหนดค่าสมมุติที่อยู่ตรงกลาง โดยจะเลือกข้อมูลที่
อยู่ตรงกลางของข้อมูลทั้งหมด มาใช้เป็นค่ากึ่งกลาง
ดังนั้น ข้อมูลอื่นๆที่มีค่ามากกว่าค่าที่อยู่ตรงกลางจะ
อยู่กลุ่มทางขวามือ ค่าที่น้อยกว่าจะอยู่กลุ่มทางซ้าย
มือ

21. Quick Sort
>
ถ้าข้อมูล < Pivot แล้ว
SortLeft=SortLeft+1
สลับ Pivot กับ
ข้อมูลตัวที่ SortLeft-1
ถ้าข้อมูล >= Pivot แล้ว
SortRight=SortRight-1

22. Quick Sort

23. Merge Sort
 การเรียงแบบผสาน (Merge Sort ) -- การทำา
Merge Sort ใช้หลักการ divide-and-conquer
เหมือนกับ Quick Sort มีลักษณะของการแบ่งข้อมูล
ออกเป็นส่วนๆ แต่กระบวนการเรียงข้อมูลนั้นจะแตก
ต่างไปจาก Quick sort Quick sort กระทำาการ
สลับข้อมูลไปพร้อมกับการแบ่งข้อมูลออกเป็นส่วนๆ
แต่ merge sort นี้ กระทำาการแบ่งข้อมูลออกเป็น
ส่วนๆก่อน แล้วค่อยเรียงข้อมูลในส่วนย่อย จากนั้น

24. Merge Sort
แบ่งข้อมูลออกเป็นข้อมูลย่อยๆ
จัดเรียงข้อมูลย่อย
นำาข้อมูลย่อยๆ นั้นมารวมกันให้เป็นข้อมูลเด

25. Radix Sort
การเรียงลำาดับแบบฐาน -- เป็นการเรียงลำาดับโดยการพิจารณา
ข้อมูลทีละหลัก
1. เริ่มพิจารณาจากหลักที่มีค่าน้อยที่สุดก่อน นั่นคือถ้าข้อมูล
เป็นเลขจำานวนเต็มจะพิจารณาหลักหน่วยก่อน
2. การจัดเรียงจะนำาข้อมูลทีละตัว แล้วนำาไปเก็บไว้ที่ซึ่งจัดไว้
สำาหรับค่านั้น เป็นกลุ่มๆ ตามลำาดับการเข้ามา
3. ในแต่ละรอบเมื่อจัดกลุ่มเรียบร้อยแล้ว ให้รวบรวมข้อมูลจาก
ทุกกลุ่มเข้าด้วยกัน โดยเริ่มเรียงจากกลุ่มที่มีค่าน้อยทีสุดก่อน
แล้วเรียงไปเรื่อยๆ จนหมดทุกกลุ่ม
4. ในรอบต่อไปนำาข้อมูลทั้งหมดที่ได้จัดเรียงในหลักหน่วย

26. Radix Sort
ช้กับข้อมูล Linked List

27. การวัดประสิทธิภาพ
Big-O
เป็นตัวบอกระดับความซับ
ซ้อนของอัลกอริธึมนั้น ซึ่ง
จะแสดงให้เห็น
ประสิทธิภาพของอัลกอริธึ
มนั้น
Number ofLoops
n
StraightInsertion
StraightSelection
Bubble
Shell Heap
Quick
25 625 55 116
100 10,000 316 664
500 250,000 2,364 4,482
1,000 1,000,000 5,623 9,965
2,000 4,000,000 13,374 10,985

28. การวัดประสิทธิภาพ
void insertion_sort(int data[], int num_elts)
{
int i, j;
for (i=0; i<num_elts; i++)
for (j=i; (j>0) && (data[j] < data[j-1]); j--)
swap(data, j, j-1);
} /* insertion_sort */
void swap(int data[], int a, int b)
{ int temp;
temp = data[a];
data[a] = data[b];
data[b] = temp;
} /* swap */
Big-O =
n2

29. การวัดประสิทธิภาพ
void selection_sort(int data[], int num_elts)
{
int i, j, lowindex;
for (i=0; i<num_elts; i++) /* Select i'th record */
{ lowindex = i; /* Remember its index */
for (j=num_elts-1; j>i; j--) /* Find the least value */
if (data[j] < data[lowindex])
lowindex = j; /* Put it in place */
if (i != lowindex) /* To reduce swap() operation */
swap(data, i, lowindex);
}
} /* selection_sort */
void swap(int data[], int a, int b)
{ int temp;
temp = data[a];
data[a] = data[b];
data[b] = temp;
} /* swap */
Big-O =
n2

30. การวัดประสิทธิภาพ
void bubble_sort(int data[], int num_elts)
{
int i, j;
for (i=0; i<num_elts; i++)
for (j=num_elts-1; j>i; j--)
if (data[j] < data[j-1])
swap(data, j, j-1);
} /* bubble_sort */
void swap(int data[], int a, int b)
{ int temp;
temp = data[a];
data[a] = data[b];
data[b] = temp;
} /* swap */
Big-O =
n2

31. การวัดประสิทธิภาพ
least significant digit (LSD)
most significant digit (MSD)
k, the size of each key
s, the chunk size used by the implementation.

32. การวัดประสิทธิภาพ