Transcript Sorting

การเรี ยงลาดับข้อมูล (Sorting)
DATA STRUCTURE AND ALGORITHM
Sorting
 การจัดเรียงข้อมูลเป็ นขัน
้ ตอนหนึ่งทีส่ าคัญในการประมวลผลข้อมูล
 ข้อมูลทีจ่ ดั เรียงแล้วช่วยให้เราทางานกับข้อมูลนัน
้ ได้ง่ายขึ้นเช่น
การแสดงผล
การคานวณ
2
ประโยชน์ดา้ นการแสดงผล
 รายการโทรศัพท์
จัดเรียงตามวันที่
3
จัดเรียงตาม Sender, Subject, Date/Time
ประโยชน์ดา้ นการค้นหาและแสดงผล
4
ประโยชน์ดา้ นการคานวณ
• การหาค่ า Median (ค่ าข้ อมูล ณ. ตาแหน่ งกลางของชุ ดข้ อมูล)
20 25 45 46 49 55 65 73 80 92 101
•การหาค่ า Maximum
20 25 45 46 49 55 65 73 80 92 101
•หากข้ อมูลไม่ ได้ จัดเรียงต้ องใช้ เวลา O(N) เพือ่ หาค่ า Max
•แต่ เมื่อข้ อมูลจัดเรียงเรียบร้ อยแล้วใช้ เวลา O(1)
5
ASCENDING VS. DESCENDING ORDER
เราสามารถจัดเรียงข้อมูลได้ทุกประเภท int, float, boolean, character, string ฯลฯ
 ข้อมูลที่จดั เรียงต้องมี Key ที่ใช้เป็ นตัววัดลาดับข้อมูลเช่น จานวน วันที่ ชือ่ เป็ นต้น
 การจัดเรียงจากน้อยไปหามาก (Ascending Order)
 เช่นเรียงตัวเลข, วันที่ในรายการสมุดบัญชีธนาคาร


การจัดเรียงมากไปหาน้อย (Descending Order)
 เช่น เรียง E-mail โดยเอาวันที่ล่าสุดขึ้นมาก่อน
6
Data Representation for Sorting
ข้อมูลที่ตอ้ งการจัดเรียงนัน้ มีอยู่หลายรูปแบบ เช่น ข้อมูลที่อยู่ใน Array, อยู่ในไลล, อยู่ในฐานข้อมูล
 ในวิชานี้เราศึกษาถึงรูปแบบการเรียงลาดับข้อมูลใน Array เท่านัน้

สมมติมขี ้ อมูล 1 ชุ ด จานวน 6 ตัว ดังนี้
44 33 11 85 77 60
ข้ อมูลในอุดมคติ
List
44 33 11 85 77 60
ข้ อมูลใน Array ชื่อ List
7
ความหมาย
การจัดเรียงลาดับ (Sorting) หมายถึงการจัดเรียงข้อมูล ให้เรียงลาดับตามเงื่อนไขทีก่ าหนดไว้
(มากไปน้อย หรือ น้อยไปมาก)
่ นใจเพื่อใช้ใน
 ในกรณีทขี่ อ้ มูลในแต่ละ Record มีหลาย Field เราต้องพิจารณาเลือก Field ทีส
การเรียงลาดับ เช่น การจัดเรียงลาดับประวัตนิ กั ศึกษา อาจใช้หมายเลขประจาตัวของนักศึกษา
เป็ น Field โดยเรียงจากน้อยไปมาก เป็ นต้น

8
ประเภทของการเรียงลาดับข้อมูล
(Internal Sorting)
 การจัดเรียงลาดับข้อมูลทีเ่ ก็บอยูใ่ นหน่วยความจาของเครือ่ งคอมพิวเตอร์
การจัดเรียงแบบนี้จะต้องอาศัยเทคนิคและวิธีการของโครงสร้างข้อมูลมาช่วย
เช่น การใช้ Array หรือ Linked-List เข้ามาช่วย
 การจัดเรียงภายนอก (External Sorting)
 การจัดเรียงข้อมูลทีเ่ ก็บอยูใ่ นสือ่ บันทึกข้อมูล เช่น Disk โดยทัว่ ไปการ
เรียงประเภทนี้ มักใช้กบั ข้อมูลทีม่ ีจานวนมาก ทีไ่ ม่สามารถเก็บไว้ใน
หน่วยความจาได้หมด การเรียงในแบบนี้จะต้องแบ่งข้อมูลออกเป็ นส่วนย่อย
แล้วนามาเรียงด้วยการจัดเรียงแบบภายในก่อน แล้วจึงนาแต่ละส่วนย่อยมา
รวมกัน
 การจัดเรียงภายใน
9
วิธีการจัดเรียงข้อมูล
(Exchange Sort)
การจัดเรียงแบบแทรก (Insertion Sort)
การจัดเรียงแบบเลือก (Selection Sort)
การจัดเรียงแบบแลกเปลี่ยน
 Merg
Sort
 Redix Sort
 Heap Sort
 Shell sort
 Quick Sort
10
การจัดเรียงแบบแลกเปลี่ยน (BUBBLE SORT)
เป็ นการจัดเรียงโดยการเปรียบเทียบค่า 2 ค่าทีต่ ดิ กัน
่ ย ๆ และตัดสินใจว่าจะสลับตาแหน่งกันหรือไม่ เช่น ถ้าต้องการเรียงข้อมูลจากน้อยไป
 ทาต่อเนื่องกันไปเรือ
มาก ก็คอื


ข้อมูลทีม่ ีคา่ น้อย ต้องอยูใ่ นตาแหน่งหน้า
่ ีคา่ มาก จะอยูต่ าแหน่งหลัง
 ข้อมูลทีม
 ข้อมูล 2 ตัวทีอ่ ยูต่ ดิ กัน ถ้า

ถ้าข้อมูลตัวแรกมากกว่าตัวหลัง ก็จะต้องสลับตาแหน่งกัน
 แต่ถา้ ข้อมูลตัวแรกน้อยกว่าข้อมูลตัวหลัง ก็ไม่ตอ
้ งสลับตาแหน่ง
่ ย ๆ จนกว่าการเปรียบเทียบของข้อมูลตลอดทัง้ ชุดจะไม่ตอ้ งมีการสลับตาแหน่งเลย
 ทาเช่นนี้ซา้ กันไปเรือ
11
BUBBLE SORT

เป็ นวิธีทงี่ ่ายเช่นกัน
่ ากๆ จะต้องถูกนาไป (ลอยไป) ไว้ดา้ นท้าย
 แนวคิด คือค่าทีม
 เหมือนลูกโป่ งทีข่ นาดใหญ่จะลอยได้เร็วและสูง
 แนวคิด







เริม่ นาข้อมูลตัวแรกเทียบกับตัวที่ 2 ตัวไหนมากก็จะถูกสลับกัน ทาอย่างนี้ไปจนถึงตัวสุดท้าย เราจะได้คา่ ทีม่ าก
ทีส่ ุด 1 ตัวไว้ดา้ นท้าย
แต่ละครัง้ จะได้คา่ มากทีส่ ุดไปไว้ทา้ ยสุด
จากนัน้ เริม่ การเปรียบเทียบใหม่ตงั้ แต่ตวั แรกถึงตัวที่ N-1
จากนัน้ เริม่ การเปรียบเทียบใหม่ตงั้ แต่ตวั แรกถึงตัวที่ N-2
…
จากนัน้ เริม่ การเปรียบเทียบใหม่ตงั้ แต่ตวั แรกถึงตัวที่ N-x
ทาจน x = N-1
12
ตัวอย่าง FUNCTION การจัดเรียงแบบ BUBBLE
13
44 55 12 42 94 18 06 67
ตัวอย่าง: BUBBLE SORT
รอบที่
1
2
3
4
5
6
7
06
06
06
06
06
06
06
44
12
12
12
12
12
12
55
44
18
18
18
18
18
ข้ อมูล 8 ตัวทา 7 รอบ
ข้ อมูล
12
55
44
42
42
42
42
42
18
55
44
44
44
44
94
42
42
55
55
55
55
18
94
67
67
67
67
67
67
67
94
94
94
94
94
14
Program bublesort1;
const n = 8;
a:array[1..n] of integer = (44,55,12,42,94,18,06,67);
VAR i,j,l,temp : integer;
begin
for i := 2 to n do
begin
for j := n downto i do
if a[j-1] > a[j] then
begin
temp := a[j-1];
a[j-1] := a[j];
a[j] := temp;
end;
for l := 1 to n do
write(a[l]:10);
end;
writeln;readln;
end.
15
#include <iostream.h>
#define ELEMENTS 8
void exchange_sort(int x[],int length)
{
int temp;
for(int i=0;i<length;i++)
{
for (int j=length;j>i;j--)
{
if(x[j-1]>x[j])
{
temp=x[j-1];
x[j-1]=x[j];
x[j]=temp;
}
}
}
}
int main()
{
int A[ELEMENTS]={44,55,12,42,94,6,18,67};
int x;
cout<<"NON SORTED LIST:"<<endl;
for(x=0;x<ELEMENTS;x++)
{
cout<<A[x]<<endl;
}
exchange_sort(A,ELEMENTS);
cout<<endl<<"SORTED LIST"<<endl;
for(x=1;x<=ELEMENTS;x++)
{
cout<<A[x]<<endl;
}
return 0;
}
16
การจัดเรียงแบบแทรก (INSERTION SORT)

เป็ นการจัดเรียงโดยการนาข้อมูลทีจ่ ะทาการเรียงนัน้ ๆ ไปจัดเรียงทีละตัว
่ ีการจัดเรียงเรียบร้อยแล้ว ณ ตาแหน่งที่
 โดยการแทรกตัวทีจ่ ะเรียงไว้ในตาแหน่งทีเ่ หมาะสมของข้อมูลทีม
ถูกต้อง
 วิธีการลักษณะนี้จะคล้ายกับการหยิบไพ่ข้ น
ึ มาเรียงทีละใบ ซึง่

ไพ่ใบแรกจะไม่ตอ้ งสนใจอะไร
 แต่เมื่อหยิบไพ่ใบที่ 2 ก็จะต้องพิจารณาว่าจะไว้ก่อนหรือไว้หลังใบแรก
 และเช่นเดียวกัน เมื่อหยิบไพ่ใบถัด ๆ มา ก็จะต้องพิจารณาว่าจะวางใบตาแหน่งใดเพื่อให้เกิดการเรียงลาดับ จนกระทัง่
หมด
17
ตัวอย่าง FUNCTION การเรียงแบบ INSERTION
18
44 55 12 42 94 18 06 67
ตัวอย่าง: INSERTION SORT
รอบที่
2
3
4
5
6
7
8
ข้ อมูล 8 ตัวทา 7 รอบ
ข้ อมูล
44
12
12
12
12
06
06
55
44
42
42
18
12
12
12
55
44
44
42
18
18
42
42
55
55
44
42
42
94
94
94
94
55
44
44
18
18
18
18
94
55
55
06
06
06
06
06
94
67
67
67
67
67
67
67
94
19
Program insertionsort;
const n = 8;
a:array[1..n] of integer = (44,55,12,42,94,18,06,67);
VAR i,j,l,x : integer;
begin
for i := 2 to n do
begin
x := a[i]; j := i-1;
while (x < a[j]) and (j > 0) do
begin
a[j+1] := a[j];
j := j - 1;
end;
a[j+1] := x;
for l := 1 to n do
write(a[l]:10);
end;
writeln;readln;
end.
20
#include <iostream.h>
#define ELEMENTS 8
void insertion_sort(int x[],int length)
{
int key,i;
for(int j=1;j<length;j++)
{
key=x[j];
i=j-1;
while(x[i]>key && i>=0)
{
x[i+1]=x[i];
i--;
}
x[i+1]=key;
}
}
int main()
{
int A[ELEMENTS]={44,55,12,42,94,06,18,67};
int x;
cout<<"NON SORTED LIST:"<<endl;
for(x=0;x<ELEMENTS;x++)
{
cout<<A[x]<<endl;
}
insertion_sort(A,ELEMENTS);
cout<<endl<<"SORTED LIST"<<endl;
for(x=0;x<ELEMENTS;x++)
{
cout<<A[x]<<endl;
}
return 0;
}
21
การจัดเรียงแบบเลือก (SELECTION SORT)

เป็ นการจัดเรียงโดยการเริม่ ต้นค้นหาข้อมูลตัวทีน่ อ้ ยทีส่ ุดจากข้อมูลทีม่ ีอยูท่ งั้ หมด
 แล้วเอามาเก็บไว้ขา้ งนอก
่ อ้ ยทีส่ ุดในกองต่อไปจนกว่าจะหมดกอง
 แล้วกลับไปหาข้อมูลตัวทีน
22
ตัวอย่าง FUNCTION การเรียงแบบ SELECTION
23
44 55 12 42 94 18 06 67
ตัวอย่าง: SELECTION SORT
รอบที่
1
2
3
4
5
6
7
ข้ อมูล 8 ตัวทา 7 รอบ
ข้ อมูล
06
06
06
06
06
06
06
55
12
12
12
12
12
12
12
55
18
18
18
18
18
42
42
42
42
42
42
42
94
94
94
94
44
44
44
18
18
55
55
55
55
55
44
44
44
44
94
94
67
67
67
67
67
67
67
94
24
Program selectionsort;
const n = 8;
a:array[1..n] of integer = (44,55,12,42,94,18,06,67);
VAR i,j,k,l,temp : integer;
begin
for i := 1 to n-1 do
begin
k := i;
for j := i+1 to n do
if a[k] >a[j] then k := j;
temp := a[i];
a[i] := a[k];
a[k] := temp;
for l := 1 to n do
write(a[l]:10);
end;
writeln;readln;
end.
25
#include <iostream.h>
#define ELEMENTS 8
int main()
{
int A[ELEMENTS]={44,55,12,42,94,6,18,67};
int x;
void selection_sort(int x[],int length)
cout<<"NON SORTED LIST:"<<endl;
{
for(x=0;x<ELEMENTS;x++)
int k,temp;
{
for(int i=0;i<length;i++)
cout<<A[x]<<endl;
{
}
k=i;
selection_sort(A,ELEMENTS);
for (int j=i+1;j< length;j++)
cout<<endl<<"SORTED LIST"<<endl;
{
for(x=0;x< ELEMENTS;x++)
if(x[j]< x[k])
{
k=j;
cout<<A[x]<<endl;
}
}
temp=x[i];
return 0;
x[i]=x[k];
}
x[k]=temp;
}
}
26
SHELLSORT
Shellsort
ตัง้ ตามชื่อของผู้คิดค้ นการจัดเรี ยงแบบนี ้ คือ Donald
Shell และเป็ นอัลกอริทมึ แรกที่ทาลายขอบเขตเวลาที่เป็ น
quadratic
ในขณะทางานแต่ ละ phase นัน
้ shell sort ใช้ การเปรี ยบเทียบ
ค่ าที่อยู่ในตาแหน่ งที่ห่างกัน ระยะห่ างดังกล่ าวนีจ้ ะลดลงลงเรื่ อย
ๆ จนกระทั่งถึงขัน้ ตอนสุดท้ ายที่เป็ นการเปรี ยบเทียบค่ าที่อยู่
ติดกัน
 ด้ วยเหตุท่ รี ะยะห่ างของค่ าที่นามาเปรี ยบเทียบกันลดลงใน
ระหว่ างการทางานของอัลกอริทมึ นีเ้ อง จึงเรียกShellsort
27
อีกอย่ างว่ า diminishing increment sort
Shellsort
ใช้ การลาดับของ h1, h2, . . . , ht ซึ่งเรี ยกว่ า
increment sequence และลาดับที่ใช้ จะมีค่าลักษณะใดก็ได้
เพียงแต่ มีเงื่อนไขว่ า h1 = 1 เท่ านัน้ แต่ แน่ นอนว่ าบางลาดับ
จะทางานได้ ดีกว่ าบางลาดับ (จะกล่ าวถึงอีกครั ง้ )
่ hk ผลที่ได้ คือ
ในการทางานแต่ phase ทีใ่ ช้ ลำดับกำรเพิม
สาหรั บแต่ ละค่ า i เราจะได้ ว่า a[i]  a[i + hk] กล่ าวคือสมาชื
กทุกตัวที่มีระยะห่ างกัน hk จะอยู่ในลาดับที่มีก่ ีจัดเรี ยงอย่ าง
ถูกต้ อง ซึ่งเรี ยกว่ า hk-sorted file
28
คุณสมบัตท
ิ ่ สี าคัญของ
Shellsort คือ การทา hk-sorted แล้ ว
ตามด้ วย hk-1-sorted นัน้ ยังคงสภาพของ hk-sorted
Original
81 94 11 96 12 35 17 95 28 58 41 75 15
-------------------------------------------------------------------------------------After 5-sort 35 17 11 28 12 41 75 15 96 58 81 94 95
After 3-sort 28 12 11 35 15 41 58 17 94 75 81 96 95
After 1-sort 11 12 15 17 28 35 41 58 75 81 94 95 96
Figure Shellsort หลังการทางานแต่ ละ pass
29
SHELLSORT ROUTINE ใช้ ลำดับกำรเพิ่มของ SHELL
public static void shellsort( Comparable [ ] a )
{
int j;
/* 1*/ for( int gap = a.length / 2; gap > 0; gap /= 2 )
/* 2*/
for( int i = gap; i < a.length; i++ )
{
/* 3*/
Comparable tmp = a[ i ];
/* 4*/
for( j = i; j >= gap &&
tmp.compareTo( a[ j - gap ] ) < 0; j -= gap )
/* 5*/
a[ j ] = a[ j - gap ];
/* 6*/
a[ j ] = tmp;
}
}
30
HEAPSORT
ในการจัดเรียงด้วยเวลา O(N log N)
อัลกอริทึมที่ใช้พ้ นื ฐานแนวคิดนี้
เรียกว่า heapsort และมี Big-Oh running time ดีกว่าอัลกอริทึมอืน่ ๆ ที่
กล่าวมาแล้ว
วิธีการ คือ สร้าง binary heap (มีสมาชิก N ตัว) ซึง่ ใช้เวลา O(N) จากนัน้
ทา deleteMin N ครัง้ สมาชิกที่ถูกย้ายออกไปจาก heap ตัวแรก คือตัวที่มี
ค่าน้อยที่สดุ และเรียงลาดับตามค่าไป แล้วนาไปเก็บใน Arrray อีกตัวหนึง่
จากนัน้ ก็คดั ลอกกลับไปยัง Array เดิมซึง่ ก็จะเป็ นคาตอบในการจัดเรียง
เนือ่ งจากการทา deleteMin แต่ละตัวใช้ O(log N) ดังนัน้ running time
รวมทัง้ หมด คือ O(N log N)
31
หลังการทางานจนเสร็จ
Array ที่ได้กจ็ ะเป็ น Arrayของสมาชิกที่จดั เรียงจาก
มากไปน้อย
 ถ้าต้องการจัดเรียงจากน้อยไปมาก เราก็จะใช้ heap ที่ parent มีค่า
มากกว่า child ของมัน นัน่ คือ (max)heap
เราจะใช้ (max)heap ในการ implement ของเราและยังคงใช้ Array เช่นเดิม
 ขัน้ แรกสร้าง heap ด้วย linear time จากนัน้ ทา deleteMaxes จานวน N
- 1 ครัง้ ด้วยการสลับสมาชิกตัวสุดท้ายใน heap กับสมาชิกตัวแรก แล้ว
ลดขนาดของ heap ลงแล้วทาการ percolating down
 หลังจบอัลกอริทึมจะได้ Arrayที่มีสมาชิกเรียงตามลาดับค่า
32
FIGURE 7.6 (MAX) HEAP หลังกำร
BUILD_HEAP
Figure 7.7 Heap หลัง
deleteMax ครั ง้ แรก 33
QUICK SORT
หลักการดาเนินงาน
* หาตาแหน่งในการแยกลิสต์
* แบ่งแยกข้อมูลออกเป็ นสองส่วน และหาตาแหน่ง
ในการแยกลิสต์
* ทาจนกว่าข้อมูลจะเรียงลาดับเรียบร้อย
34
Ex
15 9 7 16 31 2 20 25 17 12
เริ่ มต้นใช้ขอ้ มูลตัวแรกเป็ นตัวเปรี ยบเทียบ (pivot)
15 9 7 16 31 2 20 25 17 12
pivot
first
last
ทาการเปรี ยบเทียบค่าของข้อมูลที่ช้ ีโดย first กับ
Pivot ถ้าน้อยกว่า pivot ให้ทาการเลื่อน first
ไปยังข้อมูลต่อไปและเปรี ยบเทียบไปจนกว่าจะพบ
แล้วจึงหยุดการเปรี ยบเทียบ
35
15 9 7 16 31 2 20 25 17 12
first
last
เมื่อพบตาแหน่งแล้ว จะหันมาพิจารณาที่ last ชี้อยู่
หากค่าที่ last ชี้อยูม่ ีค่าน้อยกว่าที่ first ชี้อยูใ่ ห้สลับตาแหน่ง
15 9 7 12 31 2 20 25 17 16
first
last
36
จากชุดข้ อมูลหลังจากการสลับค่ า
15 9 7 12 31 2 20 25 17 16
first
last
ทาการเปรี ยบเทียบค่าของข้อมูลที่ช้ ีโดย first กับ
Pivot ถ้าน้อยกว่า pivot ให้ทาการเลื่อน first
ไปยังข้อมูลต่อไปและเปรี ยบเทียบไปจนกว่าจะพบ
แล้วจึงหยุดการเปรี ยบเทียบ
37
15 9 7 12 31 2 20 25 17 16
first
last
เมื่อพบตาแหน่งแล้ว จะหันมาพิจารณาที่ last ชี้อยู่
หากค่าที่ last ชี้อยูม่ ีค่าน้อยกว่าที่ first ชี้อยูใ่ ห้สลับตาแหน่ง
15 9 7 12 16 2 20 25 17 31
first
last
38
ย้อนกระบวนการไปพิจารณา first และ last จะได้
15 9 7 12 16 2 20 25 17 31
first last
สลับตาแหน่งข้อมูล
15 9 7 12 2 16 20 25 17 31
first last
39
ย้อนกระบวนการไปพิจารณา first และ last จะได้
15 9 7 12 2 16 20 25 17 31
last first
พบตาแหน่ งทีจ่ ะใช้ แบ่ งชุดข้ อมูลแล้ ว จึงทาการแบ่ งข้ อมูล
ออกเป็ นสองชุด
40
ทาการแบ่งข้อมูลออกเป็ นสองชุด
15 9 7 12 2
16 20 25 17 31
สลับค่ าข้ อมูลตัวแรกกับสุ ดท้ ายของข้ อมูลชุ ดซ้ าย
2 9 7 12 15
16 20 25 17 31
จะได้ ว่า 15 และ 16 อยู่ในตาแหน่ งทีถ่ ูกต้ อง(ตน.5และ ตน.6)
เรียบร้ อยแล้วไม่ตอ้ งนามาพิจารณาอีก
ดาเนินการกับข้ อมูลทีเ่ หลือเหมือนเดิมจนกว่ าจะได้ ข้อมูลใน
ตาแหน่ งต่ างๆ จนครบ และดาเนินการแบบเดียวกับกับข้ อมูล
ชุ ดขวามือ
41
ข้ อมูลเริ่มต้ นชุ ดซ้ าย
2 9 7 12
pivot first
last
ข้ อมูลเริ่มต้ นชุ ดขวา
20 25 17 31
first
last
พิจารณาชุดข้ อมูลด้ านซ้ ายมือก่อน
42
2 9 7 12
pivot first
last
2 7 9 12
pivot first
2 7 9 12
pivot
last first
last
• First มากกว่า pivot พิจารณา last เลื่อนมาด้านซ้ายจนพบ
7 ซึ่งน้อยกว่า 9 จึงหยุด ทาการสลับตาแหน่งข้อมูล
• First มากกว่า pivot พิจารณา last เลื่อนมาด้านซ้ายจนมาชี้
ที่ pivot พบว่าไม่มีขอ้ มูลใดต่อไปอีก ทาการแบ่งข้อมูล
ออกเป็ นสองชุดแสดงว่า pivot อยูใ่ นตาแหน่งที่ถูกต้องแล้ว
(2 อยู่ ตน. 1)
2
7
9 12
43
7 9 12
pivot
first last
7 9 12
pivot last first
เปรี ยบเทียบ first กับ pivot พบว่า first มากกว่า
พิจารณา last พบว่ามากกว่า first จึงเลื่อนมา
ด้านซ้ายจนมาชี้ที่ pivot และไม่มีตวั อื่นอีกจะได้
ตาแหน่งในการแยก list
44
ได้วา่ pivot (7) อยูใ่ นตาแหน่งที่ถูกต้องแล้ว
9 12
pivot
first
9 12
last
pivot
last
first
สรุ ปตาแหน่งข้อมูลที่ทราบแล้วคือตาแหน่งที่ 1 ถึง
5 ได้แก่ 2 7 9 12 และ 15 ตามลาดับ
ดาเนินการกับข้ อมูลชุดด้ านขวามือต่ อ
45
MERGE SORT
กระบวนการแยกชุดข้ อมูล
15 6 21 19 16 7 10 30
15 6 21 19
15 6
15
6
16 7 10 30
21 19
21
19
16 7
16
7
10 30
10
46
30
กระบวนการรวมชุดข้ อมูล
15
6
6 15
21
19
19 21
6 15 19 21
6
16
7
7 16
10
30
10 30
7 10 16 30
7 10 15 16 19 21 30
ได้ ชุดข้ อมูลทีเ่ รียงลาดับเรียบร้ อยแล้ว
47
MERGE SORT ALGORITHM ANALYSIS
จานวนครัง้ ของการเปรียบเทียบทัง้ หมด
= ผลบวกทุกระดับของ ( จานวนลิสตในแต่ละระดับ *
จานวนครัง้ ของการเปรียบเทียบแต่ละลิสต )
= (N-1) *1 + (N/2 -1)*2 + (N/4 – 1)*4 +..+(2-1)*N/2
= ( N-1) + (N-2)+(N-4)+..+(N-N/2)
= Nlog2N จะได้ bigO(Nlog2N)
48
วิธีการจัดเรียงข้อมูล
(Exchange Sort)
การจัดเรียงแบบแทรก (Insertion Sort)
การจัดเรียงแบบเลือก (Selection Sort)
การจัดเรียงแบบแลกเปลี่ยน
 Merg
Sort
 Redix Sort
 Heap Sort
 Shell sort
 Quick Sort
49