Transcript บทที่ 11 การจัดการเรียงข้อมูลและค้นหาข้อมูล

บทที ่ 11 การจัดเรียงและการ
ค้นหาข้อมูล
1
บทที่ 11 การจัดเรียงและการค้นหาข้อมูล
•
•
•
•
•
•
•
•
•
•
•
•
•
กล่าวนาการจัดเรียงข้อมูลและการค้นหาข้อมูล
อัลกอริทมึ รับข้อมูล
การจัดเรียงข้อมูลแบบ Selection Sort
การจัดเรียงข้อมูลแบบ Bubble Sort
การจัดเรียงข้อมูลแบบ Insertion Sort
การจัดเรียงข้อมูลแบบ Merge Sort
การจัดเรียงข้อมูลแบบ Quick Sort
การจัดเรียงข้อมูลแบบ Radix Sort
การจัดเรียงข้อมูลแบบ Heap Sort
การจัดเรียงข้อมูลแบบ Shell Sort
การค้นหาข้อมูลแบบลาดับ (Sequential search หรือ Linear search)
การค้นหาข้อมูลด้วย Binary search หรือ Half-Interval search
สรุปเนื้อหาบทที1่ 1
กล่าวนาการจัดเรียงและการค้นหาข้อมูล
• การจัดเรียงข้อมูลเป็ นการเตรียมข้อมูลให้พร้อมสาหรับการค้นหาข้อมูล
• แยกประเภทของการจัดเรียงข้อมูลได้ 2 ประเภท คือ
o internal sort เป็ นการจัดเรียงข้อมูลทีม่ ขี นาดของข้อมูลทีเ่ หมาะสมกับหน่ วยความจา
ของเครือ่ งคอมพิวเตอร์
o external sort เป็ นการจัดเรีย งข้อมูล ที่ม ีขนาดไม่เ หมาะสมกับ ขนาดของ
หน่วยความจาของเครือ่ งคอมพิวเตอร์ แต่มขี นาดของข้อมูลเหมาะสมกับขนาดในการ
เก็บข้อมูลในระดับทีส่ อง เช่น ฮาร์ดดิสก์
• ภายในบทนี้จะกล่าวถึงอัลกอริทมึ การจัดเรียงข้อมูลเป็ นแบบ internal sort ทัง้ หมด
• การค้นหาข้อมูล คือ การนาข้อมูลทีถ่ กู จัดเรียงแล้วมาค้นหาข้อมูลทีต่ ้องการ ซึง่ การค้นหา
ข้อมูลใน
3
อัลกอริทมึ รับข้อมูล
ตัวอย่างที่ 11.1 อัลกอริทมึ รับข้อมูลมาเก็บไว้ในอาร์เรย์และการเรียกใช้เมธอดในการจัดเรียงข้อมูล
Java
import java.util.Scanner;
public class SortingJava {
public static void main(String[] args) {
final int size = 100;
String key = "";
Scanner scan = new Scanner(System.in);
Comparable[] Data = new Comparable[size];
int count = 0;
//รับข้อมูลจากคียบ
์ อร์ดเข้ามาเก็บไว้ในอาร์เรย์ทาจนกระทังก้ กด ‘q’
while (!key.equals("q")){
System.out.print("Input Data"+(count+1)+":");
key = scan.nextLine();
if(!key.equals("q")){
Data[count] = Integer.parseInt(key);
++count;
}
}
//เรียกใช้เมธอดในการจัดการเรียงกข้อมูล
Data = เมธอดในการจัดเรียงข้อมูล(Data,count) ;
System.out.print("ข้อมูลทีถ่ ูกจัดเรียงข้อมูล :");
for(int i=0;i<count;i++){
System.out.print(Data[i]+" ");
}
}
}
C
#include <stdio.h>
#include <stdlib.h>
#define size 100
void main(){
char key[35];
int Data[size];
int count=0;
//รับข้อมูลจากคียบ
์ อร์ดเข้ามาเก็บไว้ในอาร์เรย์ทาจนกระทังก้ กด
while (key[0] != 'q'){
printf("Input Data %d :",(count+1));
gets(key);
if (key[0] != 'q'){
Data[count] = atoi(key);
++count;
}
}
//เรียกใช้ฟงกั ก์ชน
ั ในการจัดการเรียงกข้อมูล
int *Datashow = ฟังก์ชนั รจัดเรียงข้อมูล(Data,count);
printf("Data for Sorting :");
for(int i=0;i<count;i++){
printf("%d\t",Datashow[i]);
}
}
4
‘q’
การจัดเรียงข้อมูลแบบ Selection Sort
• ค้นหาข้อ มูล ที่มากที่สุด ในชุดข้อมูล ที่ต้อ งการจัดเรีย ง แล้ว นาข้อมูล ที่ ม ากที่สุดนี้ ไปไว้ใ น
ตาแหน่งของข้อมูลทีม่ ากทีส่ ุดในอาร์เรย์ โดยสลับตาแหน่งระหว่างตาแหน่ง ข้อมูลทีม่ ากทีส่ ุด
กับตาแหน่งทีเ่ จอข้อมูลทีม่ ากทีส่ ุด
• ขัน้ ตอนถัดไปหลังจากจัดเรียงข้อมูลทีม่ ากทีส่ ุดแล้ว คือ ค้นข้อมูลทีม่ ากทีส่ ุดในลาดับถัดไป
โดยยกเว้นการค้นหาข้อมูลในตาแหน่งทีเ่ ก็บข้อมูลทีม่ ากทีส่ ุดไปแล้วในอาร์เรย์ก่อนหน้านี้
• ทาอย่างนี้จนกระทังจั
่ ดเรีย งข้อมูล ครบทุกข้อมูล ซึ่งจะมีจานวนรอบในการจั ดเรีย งข้อมูล
เท่ากับ n-1 รอบจากข้อมูล n ข้อมูล
• ดังกนัน้ ข้อมูลทีม่ ากทีส่ ุดจะอยูใ่ นตาแหน่งกขวาสุด
5
การจัดเรียงข้อมูลแบบ Selection Sort
6
การจัดเรียงข้อมูลแบบ Selection Sort
ตัวอย่างที่ 11.2 Pseudo code ในการจัดเรียงข้อมูลแบบ Selection sort
1
+selectionSort(inout theArray[]:ItemArray,in n:integer):ItemArray
2
for(last = n-1 downto 1){
3
largest = indexofLargest(theArray,last+1)
4
swap(theArray[last+1],theArray[largest])
5
}
6
return theArray
7
+indexofLargest(in theArray[]:DataType,in size:integer):integer
8
indexSoFar = 0;
9
for(currIndex=1 to size){
10
if(theArray[currIndex) > theArray[indexSoFar]){
11
indexSoFar = currIndex
12
}
13
}
14
return indexSoFar
วิเคราะห์หาประสิทธิภาพการจัดเรียงข้อมูลแบบ Selection sort
• ลูป for ในฟงั ก์ชนั /เมธอด selectionSort วนลูปเท่ากับ n ครัง้
n 1
• ลูป for ในฟงั ก์ชนั /เมธอด indexofLargest วนลูปเท่ากับ 2
• ในบรรทัดที่ 10-11 ทาค1าสัง่ n2i คาสัง่
ดังนัน้ worst-case เท่ากับ
 2 =
i  n 1 i 1
 n  1  2n n  1  n 2  n
=
2

 =

2


i  n 1  2 
1
ทำให้ worst-case ของกำรจัดเรียงข้อมูลแบบ Selection sort เท่ำกับ O( n 2 )
7
การจัดเรียงข้อมูลแบบ Bubble Sort
• การจัดเรียงข้อมูลแบบ Bubble sort เริม่ จากเปรียบเทียบข้อมูลในตาแหน่งแรกกับ ข้อมูลใน
ตาแหน่ งที่ 2 ในอาร์เรย์ ถ้าไม่ตรงตามข้อกาหนดทีก่ าหนดไว้ให้สลับตาแหน่ งกันระหว่าง
ข้อมูลทัง้ สอง
• ต่อไปเปรียบเทียบข้อมูลคู่ต่อไป คือ ข้อมูลตาแหน่ งที่ 2 กับ 3 ว่าตรงตามข้อทีก่ าหนด
หรือไม่ ถ้าไม่ตรงตามข้อที่กาหนดไว้ให้สลับตาแหน่ งกัน และทาจนกระทังสิ
่ น้ สุดข้อมูลใน
อาร์เรย์
8
การจัดเรียงข้อมูลแบบ Bubble Sort
ตัวอย่างที่ 11.3 Pseudo code การจัดเรียงข้อมูลแบบ Buffer sort
1
2
3
4
5
6
7
8
+bubbleSort(inout theArray[]:ItemArray,in n:integer):ItemArray
for(pass=1 to n-1){
for(index=0 to n-pass){
if(theArry[index] > theArry[index+1]){
swap(theArray[index],theArray[index+1]
}
}
}
วิเคราะห์หาประสิทธิภาพการจัดเรียงข้อมูลแบบ Bubble sorted
1. ในลู for ในบรรทัดที่ 2 - 8 วนลู เท่ากับ n ครังก้
2. ในลู for ในบรรทัดที่ 3 – 7 วนลู เท่ากับ n  1 ครังก้
2
3. ในบรรทัดที่ 4 -5 ทาคาสังกเท่
่ ากับ 2 คาสังก่
 n 1
 n 1
2
2
2
n
=



 = n n

 2 
i 1 i 1
i 1  2 
ทำให้ worst-case ของกำรจัดเรียงข้อมูลแบบ Bubble sort เท่ำกับ O( n 2 )
n
n i
ดังกนัน้ worst-case เท่ากับ  2 =
n
best-case ของการจัดเรียงข้อมูลแบบ Bubble sort คื อ จัดเรียงข้อมูลเพียงรอบเดียว คือ
เปรียบเทียบข้อมูลเพียง n-1 รอบ เท่ากับ O(n)
9
การจัดเรียงข้อมูลแบบ Insertion Sort
• การจัดเรียงข้อมูลแบบ Insertion sort เป็ นการจัดการเรียงข้อมูลด้วยเทคนิคการแทรกข้อมูล
10
การจัดเรียงข้อมูลแบบ Insertion Sort
ตัวอย่างที่ 11.4 Pseudo code ในการจัดเรียงข้อมูลแบบ Insertion sort
1
2
3
4
5
6
7
8
9
10
11
+insertionSort(inout theArray[]:ItemArray,in n:integer): ItemArray
for(unsorted = 1 to n-1){
nextItem = theArray[unsorted]
loc = unsorted
while(loc>0 and theArray[loc-1]>nextItem){
theArray[loc] = theArray[loc-1]
loc-}
theArray[loc] = nextItem
}
retrun theArray
วิเคราะห์หาประสิทธิภาพการจัดเรียงข้อมูลแบบ Insertion Sorted
ลู ในฟงกั ก์ชนั /เมธอด insertionSort มีทงกั ้ หมดสองกลู คอ ลู for และลู while ดยในลู for จะวน
n  1
 ดังกนัน้
2


ลู เท่ากับ จานวนข้อมูล คอ n ครังก้ ดังกนัน้ f(n) = n และในลู while จะวนลู เท่ากัน n  
ทังก้ หมดมีค่าดังกนี้
f(n) =
n2 n
 n 1
2
  n= n  n  2
n
  n=
2 2
 2 
ดังกนัน้ อัลกอรทมกำรจัดเรียงข้อมูลแบบ Insertion sort มี ่ำ worst-case เท่ำกับ O( n )
2
11
การจัดเรียงข้อมูลแบบ Merge Sort
• การจัดเรียงข้อมูลแบบ Merge sort เป็ นการจัดเรียงข้อมูลทีม่ ปี ระสิทธิภาพ โดยจะใช้หลักการการเรียกซ้า
(Recursive) ของอัลกอริทมึ ทีท่ าหน้าทีใ่ นการจัดเรียงข้อมูลกลับมาใช้ใหม่ตลอด
• การจัดเรียงข้อมูลแบบ Merge sort จะเริม่ จากแบ่งข้อมูลในอาร์เรย์ออกเป็ นส่วนย่อยแล้วนาข้อมูลใน
ส่วนย่อยนี้ไปจัดเรียงข้อมูลภายในส่วนย่อยนัน้ ๆ เมื่อจัดเรียงข้อมูลในส่วนย่อยเสร็จเรียบร้อยแล้ว ก็จะนา
ข้อมูลในส่วนย่อยกลับมารวมกัน (Merge) ใหม่อกี ครัง้ หนึ่ง
12
การจัดเรียงข้อมูลแบบ Merge Sort
ตัวอย่างที่ 11.5 Pseudo code ในการจัดเรียงข้อมูลแบบ Merge sort
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
+mergeSort(inout theArray[]:ItemArray,in first:integer,in last:integer): ItemArray
if(first < last){
mid = (first+last)/2
mergeSort(theArray,first,mid)
mergeSort(theArray,mid+1,last)
merge(theArray,first,mid,last)
}
retrun theArray
+merge((in theArray[]:DataType,in first:integer,in mid:integer,in last:integer)
tempArray = create new array
first1 = first
last1 = mid
first2 = mid+1
last2 = last
index = first
while(first1 <= last1)&&(first2 <= last2){
if(theArray[first1] < theArray[first2]){
tempArray[index] = theArray[first1]
first = first1+1
}else{
tempArray[index] = theArray[first2]
first2 = first2+1
}
index = index+1
}
while(first1 <= last1){
tempArray[index] = theArray[first1]
first1 = first1+1
index = index+1
}
while(first2 <= last2){
tempArray[index] = theArray[first2];
first2 = first2+1
index = index+1
}
for(index = first;index <= last;index++){
theArray[index] = tempArray[index];
}
13
การจัดเรียงข้อมูลแบบ Merge Sort
วิเคราะห์ประสิทธิภาพการจัดเรียงข้อมูลแบบ Merge sort
การเรียกใช้ฟงั ก์ชนั /เมธอด mergesort ในครัง้ ที่ 1 (ลาดับขัน้ ที่ 0 ในรูป (b)) แบ่งข้อมูลออกเป็ นสองส่วน
และเมือ่ เรียกฟงั ก์ชนั /เมธอด mergesort ในครัง้ ต่อไป (ลาดับขัน้ ที่ 1 ในรูปที่ (b)) จะแบ่งข้อมูลทัง้ หมดออกเป็ น
สีส่ ว่ น ทาจนกระทัง้ แยกจานวนกลุม่ ข้อมูลเท่ากับจานวนข้อมูลในอาร์เรย์คอื n ข้อมูล
ดังนัน้ ในการแบ่งข้อมูลเพื่อใช้ในการจัดเรียงข้อมูลเหมือนกับการหารสองของขนาดกลุ่ม ข้อมูลในการ
จัดเรียงข้อมูลซึง่ มีคา่ เป็ น f(n) = log2 n และมีรอบในการจัดเรียงข้อมูลทัง้ หมด n ข้อมูล ดังนัน้
ในกรณี ของ worst-case การจัดเรียงข้อมูลแบบ Merge sort มีค่า big O เท่ากับ O (n  log2 n )
14
การจัดเรียงข้อมูลแบบ Quick Sort
• การจัดเรียงข้อมูลแบบ Quick sort มีโครงสร้างในการแบ่งข้อมูลดังแสดงในรูป โดยตาแหน่ งของ
pivotIndex คือตาแหน่งทีใ่ ช้เป็ นข้อมูลหลักในการเปรียบเทียบเพือ่ จัดเรียงข้อมูล
• ในการจัดเรียงข้อมูลจะนาข้อมูลทีจ่ ะจัดเรียงมาเปรียบเทียบกับข้อมูล p และข้อมูลในส่วน s1 จะมีขอ้ มูลอยู่
ในช่วง s1 = theArray[first … pivotIndex-1] ซึง่ ข้อมูลทัง้ หมดในช่วงนี้จะมีค่าน้อยกว่าข้อมู ล p และข้อมูล
ทีอ่ ยูใ่ นช่วง s2= theArray[pivotIndex+1… last] เป็ นข้อมูลทีม่ คี า่ มากกว่าหรือเท่ากับ p
• ในการจัดเรียงข้อมูลแบบ Quick sort ได้มหี ลักการและโครงสร้างของข้อมูลดังแสดงในรูป โดยเริม่ จาก
กาหนดให้ตาแหน่งแรกในอาร์เรย์เป็ นตาแหน่งของ pivot เพื่อใช้เป็ นค่าสาหรับเปรียบเทียบในการจัดเรียง
ข้อมูล ซึง่ ข้อมูลทีน่ ้อยกว่า pivot จะเก็บข้อมูลต่อจากตาแหน่งของ pivot คือข้อมูลในส่วน s1 และข้อมูลที่
มากกว่า pivot คือส่วน s2 ซึง่ จะเก็บต่อจากข้อมูลส่วน s1 และข้อมูลส่วน Unknown คือทีย่ งั ไม่ได้จดั เรียง
ข้อมูล และได้แสดงตัวอย่างในการจัดเรียงข้อมูลแบบ Quick sort ได้ในรูปด้านล่าง
15
การจัดเรียงข้อมูลแบบ Quick Sort
16
การจัดเรียงข้อมูลแบบ Quick Sort
ตัวอย่างที่ 11.6 อัลกอริทมึ ในการจัดเรียงข้อมูลแบบ Quick sort
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
+quickSort(inout theArray[]:ItemArray,in first:integer,in last:integer):ItemArray
if(first < last){
Choose a pivot item p from theArray[first..last]
Partition the items of theArray[first..last] about p
quickSort(theArray,first,pivotIndex-1)
quickSort(theArray,pivatInde+1,last)
return theArray
+partition(in theArray[]:DataType,in first:integer,in last:integer):integer
Choose the pivot and swap it with theArray[first]
p = theArray[fist]
lastS1 = first
firstUnknown = first+1
while(firstUnknown <= last)
if(theArray[fistUnknown] < p){
Move theArray[fistUnknown] into S1
}else{
Move theArray[fistUnknown] into S2
}
}
Swap theArray[first] with theArray[lastS1]
return lastS1
17
การจัดเรียงข้อมูลแบบ Quick Sort
วิเคราะห์ประสิทธิภาพการจัดเรียงข้อมูลแบบ Quick sort
วิเคราะห์ประสิทธิภาพรูป (a)
ข้อมูลของ pivot มีค่าน้อยทีส่ ุดในอาร์เรย์ ซึง่ ใน
กรณีน้ีต้องเปรียบเทียบข้อมูลทัง้ หมด n-1 ครัง้
จากข้อมูลทัง้ หมด n ข้อมูล และในรอบต่อไปใน
การเรีย กใช้ ฟ งั ก์ ช ัน /เมธอด quickSort ซ้ า จะ
เปรียบเทียบข้อมูลเท่ากับ n-2 ครัง้ ทาจนกระทัง้
ข้อมูลในการจัดเรียงเหลือ 1 ข้อมูล ซึง่ เท่ากับ
1 + 2 + .... + ( n – 1) =
 n  1
n

 2 
=
1 2
( n  n)
2
worst-case ของ Quick sort อ O( n 2 )
วิเคราะห์ประสิทธิภาพรูป (b)
การจัดเรียงข้อมูลที่ม ีทงั ้ ส่วน s1 และ s2 เมื่อ
พิจารณาค่า average-case คือมีจานวนข้อมูล
ภายใน s1 และ s2 ที่ม ีค่ า ที่ใ กล้เ คีย งกั น ใน
(a)
(b)
กรณีน้คี า่ big-O จะเท่ากับ O( log n )
มีการวนลู ตามจานวนข้อมูลทังก้ หมด n ข้อมูล และจัดเรียงกข้อมูลเท่ากับ log2 n ดังกนัน้ ทาให้ big-O ของ
average-case เท่ำกับ O( n  log2 n )
18
2
การจัดเรียงข้อมูลแบบ Radix Sort
การจัดเรียงข้อมูลแบบ Radix sort ได้ใช้หลักการของการจัดกลุ่มและการรวมกันของข้อมูลเพื่อจัดเรียงข้อมูล
ในการจัดเรียงข้อมูลจะใช้เทคนิคการแยกข้อมูลตามตัวอักษร ดังตัวอย่างต่อไปนี้
ABC, XYZ, BWZ, AAC, RLT, JBX, EDT, KLT, AEQ, TLJ
1. เริม่ จัดเรียงโดยนาข้อมูลตัวอักษรตัวสุดท้ายในแต่ละข้อมูลนามาจัดกลุม่ ข้อมูลได้ดงั นี้
(ABC, AAC) (TLJ) (AEO) (RLT, RDT, KLT) (JBX) (XYZ, BWZ)
2. เมือ่ จัดเรียงข้อมูลแล้วจะเห็นได้วา่ ตัวอักษรตัวสุดท้ายในแต่ละกลุ่มข้อมูลจะมีตัวอักษรตัวเดียวกัน เมือ่
จัดกลุม่ ตัวอักษรเสร็จแล้วนาข้อมูลทัง้ หมดมาจัดเรียงใหม่จะได้ดงั นี้
ABC, AAC, TLJ, AEO, RLT, RDT, KLT, JBX, XYZ, BWZ
3. ต่อไปจัดเรียงตามตัวอักษรในตาแหน่งที่ 2 ของแต่ละข้อมูล ได้ดงั นี้
(AAC) (ABC, JBX) (RDT) (AEO) (TLJ, RLT, KLT) (BWZ) (XYZ)
4. และนาข้อมูลทีจ่ ดั กลุม่ ครัง้ ที่ 2 มาจัดเรียงต่อเนื่องกันจะได้ดงั นี้
AAC, ABC, JBX, RDT, AEO, TLJ, RLT, KLT, BWZ, XYZ
5. ต่อไปจัดเรียงตามตัวอักษรในตาแหน่งตัวอักษรตัวแรกของแต่ละข้อมูล ได้ดงั นี้
(AAC, ABC, AEO) (BWZ) (JBX) (KLT) (RDT, RLT) (TLJ) (XYZ)
6. และนาข้อมูลทีจ่ ดั กลุม่ ครัง้ ทีส่ ามมาเรียงต่อเนื่องกันจะได้ดงั นี้
AAC, ABC, AEO, BWZ, JBX, KLT, RDT, RLT, TLJ, XYZ
19
การจัดเรียงข้อมูลแบบ Radix Sort
ตัวอย่างในการจัดเรียงข้อมูลแบบตัวเลขจานวน 8 ข้อมูล โดยใช้หลักการในการจัดเรียงข้อมูลแบบ Radix sort
0123, 2154, 0222, 0004, 0283, 1560, 1061, 2150
(1560, 2150) (1061) (0222) (0123, 0283) (2154, 0004)
1560, 2150, 1061, 0222, 0123, 0283, 2154, 0004
(0004) (0222, 0123) (2150, 2154) (1560, 1061) (0283)
0004, 0222, 0123, 2150, 2154, 1560, 1061, 0283
(0004, 1061) (0123, 2150, 2154) (0222, 0283) (1560)
0004, 1061, 0123, 2150, 2154, 0222, 0283, 1560
(0004, 0123, 0222, 0283) (1061, 1560) (2150, 2154)
0004, 0123, 0222, 0283, 1061, 1560, 2150, 2154
: ข้อมูลเริม่ ต้น
: จัดกลุม่ ข้อมูลตามตาแหน่งที่ 4
: รวมข้อมูล
: จัดกลุม่ ข้อมูลตามตาแหน่งที่ 3
: รวมข้อมูล
: จัดกลุม่ ข้อมูลตามตาแหน่งที่ 2
: รวมข้อมูล
: จัดกลุม่ ข้อมูลตามตาแหน่งที่ 1
: รวมข้อมูลทีจ่ ดั เรียงเรียบร้อย
20
การจัดเรียงข้อมูลแบบ Radix Sort
ตัวอย่างที่ 11.7 Pseudo code การจัดเรียงข้อมูลแบบ Radix sort
1
2
3
4
5
6
7
8
9
10
11
12
13
+radixsort (inout theArray:ItemArray,in n:integer,in d:integer)
//Sorts n d-digit integers in the array theArray.
for(j = d down to 1){
Initialize 10 groups to empty
Initialize a counter for each group to 0
for(i = 0 through n-1){
k = jth digit of theArray[i]
Place theArray[i] at the end of group k
}//end for i
Replace the item in theArray with all the item in group 0,followed by all
the item in group 1, and so on
return theArray
}//end for j
วิเคราะห์การจัดเรียงข้อมูลแบบ Radix sort
การจัดเรียงกข้อมูลแบบ Radix sort จะต้องกจัดเรียงกข้อมูลทังก้ หมด n ข้อมูล ในแต่ละรอบการทางกาน
ดยมีรอบการจัดเรียงกเท่ากับขนาดของกข้อมูล คอ d ทาให้จานวนรอบในการจัดเรียงกของก Radix sort เท่ากับ
n  d รอบ งก่ ทาให้ worst-case กำรจัดเรียงข้อมูลแบบ Radix sort อ O( n )
21
การจัดเรียงข้อมูลแบบ Heap Sort
• Heap sort เป็ นอัลกอริทมึ ทีใ่ ช้โครงสร้างฮีพมาจัดเรียงข้อมูลในอาร์เรย์ ซึง่ ขัน้ ตอนแรก คือ การเปลีย่ นข้อมูลใน
อาร์เรย์ให้เป็ นฮีพ
• จากข้อมูลในอาร์เรย์ในรูป (a) สิง่ แรกลองจิตนากรให้อยู่ในรูปแบบของไบนารีทรีดงั แสดงในรูป (b) ต่อไป
เปลีย่ นทรีให้เป็ นฮีพด้วยการเรียกใช้ฟงั ก์ชนั /เมธอด heapRebuild แต่ทรีในรูป (b) ไม่ใช่ฮพี ครึง่ (semiheap)
ส่วนตาแหน่งโหนดใบเป็ นฮีพครึง่ ดังนัน้ เริม่ ปรับทรีให้เป็ นฮีพโดยเริม่ จากตาแหน่งโหนดใบจากขวาไปซ้าย และ
เลือ่ นข้อมูลไปแทนข้อมูลในโหนดพ่อแม่จนเป็ นฮีพ
(a)
(b)
22
การจัดเรียงข้อมูลแบบ Heap Sort
จากการเปลีย่ นอาร์เรย์ theArray จานวน n ข้อมูล เป็ นฮีพนัน้ เป็ นขัน้ ตอนแรกในการจัดเรียงข้อมูลด้วยฮีพ โดย
การเรียกใช้ฟงั ก์ชนั /เมธอด heapRebuild(theArray, index, n) โดยที่
 index คือ ตาแหน่งของฮีพ
 n คือ ขนาดของอาร์เรย์
โดยมีขนั ้ ตอนการปรับอาร์เรย์ให้เป็ นฮีพได้ดงั นี้
23
การจัดเรียงข้อมูลแบบ Heap Sort
และเมือ่ ได้โครงสร้างฮีพแล้ว จะได้ขอ้ มูลทีม่ ากทีส่ ดุ ไปเก็บไว้ในอาร์เรย์ การจัดเรียงข้อมูลแบบฮีพจะแบ่งอาร์เรย์
ออกเป็ น 2 ส่วน คือ ส่วนฮีพและส่วนจัดเรียงข้อมูลดังแสดงในรูป
24
การจัดเรียงข้อมูลแบบ Heap Sort
25
การจัดเรียงข้อมูลแบบ Heap Sort
ตัวอย่างที่ 11.8 Pseudo code การจัดเรียงข้อมูลแบบ Heap sort
1
2
3
4
5
6
7
8
9
10
11
12
33
40
15
16
17
18
19
20
21
22
+heapsort (inout theArray:ItemArray,in n:integer):ItemArray
for(last=n-1 downto 1){
heapRebuild(theArray,0,last)
Swap theArray[0] with theArray[last]
}
return theArray
+heapRebuild(in theArray:ItemArray,in root:integer,in n:integer)
child = 2*root+1
rightChild = child+1
if(rightChild <= n)
if(theArray[rightChild) > theArray[child]))
child = rightChild
if(theArray[root] < theArray[child]){
Swap theArray[root] with theArray[child]
heapRebuild(theArray,child,n)
}
}else if(child <= n){
if(theArray[root] < theArray[child]){
Swap theArray[root] with theArray[child]
heapRebuild(theArray,child,n)
}
}
วิเคราะห์การจัดเรียงข้อมูลแบบ Heap sort
ระสทธ า การจัดเรียงกข้อมูลแบบ Heap sort มี ระสทธ า เหมอนการจัดเรียงกข้อมูลแบบ Merge sort คอ
worst-case เ O(n * log n)
26
การจัดเรียงข้อมูลแบบ Shell Sort
• Shell sort เป็ นอัลกอริทมึ ในการจัดเรียงข้อมูลทีละ h ข้อมูล โดยทีข่ อ้ มูล h ต้องเป็ นตัวเลขจานวนเต็มบวก และ
จะจัดเรียงจนข้อมูลใน h เท่ากับ 1
• ประสิทธิภาพการจัดเรียงข้อมูลแบบ Shell sort ในกรณีทแ่ี ย่ทส่ี ดุ คือ O(n2)
27
การจัดเรียงข้อมูลแบบ Shell Sort
ตัวอย่างทื่ 11.9 Pseudo code การจัดเรียงข้อมูลแบบ Shell sort
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
+shellSort(inout theArray:ItemArray,in n:integer):ItemArray
h = n/2
while(h > 0){
shell(theArray,h,n)
h = h/2
}
return theArray
+shell(inout theArray:ItemArray,in h:integer,in n:integer)
index = find max index insert
while(index > 0){
indexData1 = 0
indexData2 = indexData1 + h
while(indexData2 < index){
if(theArray[indexData1] > theArray[indexData2]){
Swap theArray[indexData1] with theArray[indexData2]
}
indexData1 = indexData2
indexData2 = indexData2 + h
}
index = index - h
}
วิเคราะห์การจัดเรียงข้อมูลแบบ Shell sort
ระสทธ า การจัดเรียงกข้อมูลแบบ Shell sort จะมี ระสทธ า เหมอนการจัดเรียงกข้อมูลแบบ red-black
Tree และ AVL Tree คอ worst-case เ O(log n)
28
การค้นหาข้อมูลแบบลาดับ (Sequential search
หรือ Linear search)
• การค้นหาข้อมูลแบบลาดับจากอาร์เรย์ขนาด n ข้อมูล ซึง่ ก่อนทีจ่ ะค้นหาข้อมูลต้องนา
ข้อมูลทัง้ หมดไปจัดเรียงข้อมูลเสียก่อน
• หลักการค้นหาข้อมูลแบบลาดับ เริม่ จากนาข้อมูลที่ต้องการค้นหาไปเปรี ยบเทียบกับ
ข้อมูลในอาร์เรย์ตาแหน่ง 0 ว่ามีขอ้ มูลตรงกับข้อมูลทีต่ อ้ งการค้นหาหรือไม่ ถ้าไม่ตรงกัน
ให้เปรียบข้อมูลทีต่ อ้ งการค้นหากับข้อมูลในตาแหน่งถัดไปในอาร์เรย์ คือ ตาแหน่งที่ 1 ว่า
ข้อมูลตรงกันหรือไม่ ซึ่งถ้าไม่ตรงกันให้เปรียบเทียบข้อมูลในตาแหน่ ง ถัดไปเรื่อยๆ จน
เจอข้อมูลหรือจนสิน้ สุดข้อมูลทีต่ อ้ งการค้นหา
29
การค้นหาข้อมูลแบบลาดับ
วิเคราะห์การค้นหาข้อมูลแบบลาดับ
• การหาประสิทธิภาพในการค้นหาในกรณีทด่ี ที ส่ี ุด (base-case) คือ เจอข้อมูลในตาแหน่ ง
แรกของอาร์เรย์ ดังนัน้ base-case ในการค้นหาคือ O(1)
• กรณีของ worst-case คือ การเจอข้อมูลในตาแหน่งสุดท้ายของอาร์เรย์ ดังนัน้ worst-case
ในการค้นหาคือ O(n)
• ส่วน average-case ทีค่ าดว่าจะหาข้อมูลเจอในตาแหน่งตรงกลางของอาร์เรย์ คือ ตาแหน่ง
ที่ n/2 ของอาร์เรย์ ดังนัน้ ค่า average-case ในการค้นหาคือ O(n)
30
การค้นหาข้อมูลด้วย Binary search หรือ
Half-Interval search
• การค้นหาแบบไบนารีมปี ระสิทธิภาพมากกว่าการค้นหาแบบลาดับ
• หลักการการค้นหา คือ นาขนาดของอาร์เรย์ทงั ้ หมดมาแบ่งครึง่ และในการแบ่งครึง่ ทุกครัง้ จะเปรียบเทียบเพือ่
หาข้อ มูล ที่ต้อ งการค้น หาว่า ข้อ มูล ที่ต้อ งการค้น หาจะอยู่ใ นช่ว งใดของอาร์เ รย์ โดยจ านวน ครัง้ ในการ
เปรียบเทียบจะเท่ากับจานวนการแบ่งอาร์เรย์ในการเปรียบเทียบ ซึง่ มีคา่ เท่ากับ
ดยที่ k คอจานวน
k
n2
ครังก้ ในการแบ่งกในการเ รียบเทียบ และมีลาดับในการค้นหาดังกนี้
1. ตรวจสอบครงก่ หน่งกของกอาร์เรย์ขนาด n
2. ตรวจสอบครงก่ หน่งกของกอาร์เรย์ขนาด n/2
3. ตรวจสอบครงก่ หน่งกของกอาร์เรย์ขนาด n/22 ทาจนกระทังก้ เจอข้อมูลหรอไม่ตรงกตามเงกอ่ นในการค้นหาข้อมูล
แบบไบนารี
31
การค้นหาข้อมูลด้วย Binary search
ตัวอย่างที่ 11.9 ค้นหาข้อมูล 9 และ 6 ด้วยการค้นหาข้อมูลแบบไบนารี
32
การค้นหาข้อมูลด้วย Binary search
ตัวอย่างที่ 11.9 (ต่อ) ค้นหาข้อมูล 9 และ 6 ด้วยการค้นหาข้อมูลแบบไบนารี
33
การค้นหาข้อมูลด้วย Binary search
วิเคราะห์การค้นหาข้อมูลแบบไบนารี
ระสทธ า การค้นหา ข้อมูล แบบไบนารี จะเห็นได้ว่าจะต้องกแบ่งกข้อมูลเท่ากับ k ครังก้ เ ่อค้นหา
ข้อมูล จนเจอ ดังกนัน้ n/2k = 1 ( า้ สมมุตว่า n = 2k) ในกร ีทเ่ี ็ น worst-case คอ ต้องกแบ่งกข้อมูลทังก้ หมด k
ครังก้ และเ รียบเทียบทังก้ หมด k ครังก้ เ ราะว่า n = 2k และใช้หลักการทางกค ต าสตร์จะได้ k  log2 n ดังกนัน้
worst-case ของอัลกอรทม อ O( log2 n ) เมอ n = 2k
34
สรุปเนื้อหาบทที่ 11
• การจัดเรียงข้อมูลเป็ นการเตรียมข้อมูลให้พร้อมสาหรับการค้นหาข้อมูล การจัดเรียงข้อมูล
ในหนังสือเล่มนี้เป็ นการจัดเรียงข้อมูลทีข่ นาดเหมะสมกับหน่วยความจาเครื่องคอมพิวเตอร์
• การจัดเรียงข้อมูลจะวัดประสิทธิภาพดัวยคุณสมบัติ Big-O โดยรูปแบบการจัดเรียงข้อมูลที่
มีประสิทธิภาพจะมีการเขียนโปรแกรมทีซ่ บั ซ้อนกว่ารูปแบบการจัดเรียงข้อมูลทีต่ อ้ งใช้เวลา
ในการประมวลมากหรือมีประสิทธิภาพต่า
• การค้นหาข้อมูลมี 2 แบบคือค้นหาข้อมูลแบบลาดับและแบบไบนารี ซึง่ การค้นหาข้อมูลทีม ี
ประสิทธิภาพมากทีส่ ุด คือ การค้นหาข้อมูลแบบไบนารี
35