Transcript ppt
Data Structure and Algorithm
การเรี ยงลาดับข้อมูล (Sorting)
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)
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
44
12
12
12
12
06
06
55
44
42
42
18
12
12
12
55
44
44
42
18
18
ข้ อมูล 8 ตัวทา 7 รอบ
ข้ อมูล
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
อีกอย่ างว่ า diminishing increment sort
27
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
30
46
กระบวนการรวมชุดข้ อมูล
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