การจัดเรียงข้อมูล (sorting)
Download as PPT, PDF8 likes19,967 views
วิชาโครงสร้างข้อมูล
![การวัดประสิทธิภาพ
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](https://image.slidesharecdn.com/datastrucweek12sorting-150127062436-conversion-gate01/85/sorting-28-320.jpg)
![การวัดประสิทธิภาพ
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](https://image.slidesharecdn.com/datastrucweek12sorting-150127062436-conversion-gate01/85/sorting-29-320.jpg)
![การวัดประสิทธิภาพ
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](https://image.slidesharecdn.com/datastrucweek12sorting-150127062436-conversion-gate01/85/sorting-30-320.jpg)
การจัดเรียงข้อมูล (sorting)
- 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 ให้ทำาซำ้า จนกระทั่งเหลือข้อมูลกลุ่มเดียว
- 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 นี้ กระทำาการแบ่งข้อมูลออกเป็น ส่วนๆก่อน แล้วค่อยเรียงข้อมูลในส่วนย่อย จากนั้น
- 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.