(Big One) C Language - 10 เทคนิคอัลกอริทึมแบบ divide-and-conquer

เทคนิคอัลกอริทึมแบบ
Divide-and-Conquer
Advance Computer Programming
รหัสวิชา 32090207
อ. กิตตินันท์ น้1อยมณี 1

เนื้อหา
1. Introduction
2. Binary Search
3. Select Sort
4. Merge Sort
5. Divide-and-Conquer

Introduction

Introduction
• เราจะใช้ Big O ในการวิเคราะห์ Worse Case ของ
แต่ละกรณี
• แทนด้วยสัญลักษณ์ O( symbol )

Introduction
การวิเคราะห์การใช้เวลาของอัลกอริทึม
t = f(n)
n (ขนาดข้อมูลที่โตขึ้นเรื่อยๆ)
O(n!)
O(2n)
O(n2)
O(n)
O(1)

Introduction
O(n2)
O(n)

Introduction
t = f(n)
O(n!)
O(2n)
O(n2)
O(n)
O(1)
O( n logn )
O( logn )

Introduction
t = f(n)
O(n!)
O(2n)
O(n2)
O(n)
O(1)
O( n logn )
O( logn )
Sort
Search
สูตรเฉพาะ เช่น เกาส์

Binary Search

Binary Search
• แรกเริ่มเดิมทีเราจะใช้การ Search แบบ Linear
Search (หรือเรียกว่า Sequential Search) ซึ่งมี
ลักษณะการทํางานดังนี้

Binary Search

Binary Search
0 1 2 3 4 5
7 4 1 8 3 2

Binary Search

Binary Search
• แต่กว่าจะเจอข้อมูลที่ต้องการใช้เวลานาน
• กรณีที่แย่ที่สุด (Worse Case) ก็คือกรณีที่เลขที่
ต้องการค้นหาอยู่ด้านหลังสุดของ Array แสดงว่า
เราต้องวนจนสุด Loop กันเลยทีเดียว
• ดังนั้นจึงมีการคิดค้นการ Search อีกรูปแบบคือ
Binary Search (มีเงื่อนไขข้อมูลใน Array ต้องถูก
เรียงมาก่อนแล้ว) อ. กิตตินันท์ น้1อยมณี 17

Binary Search
0 1 2 3 4 5
Data 1 2 4 5 8 9 Find 8
• หลักการคือ ตัดชุดข้อมูลที่ไม่สนใจออกครึ่งนึงเลย
• วิธีการคือ กําหนดให้
– i ชี้ที่ Front (ด้านหน้าสุด)
– j ชี้ที่ Rear (ด้านหลังสุด)
– m ชี้ที่ Middle (ด้านกลาง)

Binary Search
0 1 2 3 4 5
Data 1 2 4 5 8 9 Find 8
i jj
• ก่อนเข้า Loop ต้องให้ i = 0 และ j = n-1 (ตัว
สุดท้าย)
• หลักการคือเอา data[m] ไปเทียบกับ find
mm

Binary Search
0 1 2 3 4 5
Data 1 2 4 5 8 9 Find 8
i jj
รอบที่ 0 i = 0 รอบแรก %2 Floor j = n - 1
รอบที่ 1
mm

Binary Search
0 1 2 3 4 5
Data 1 2 4 5 8 9 Find 8
i jj
รอบที่ 1 i = m+1
= 3
m = 2 j = 5
mm

Binary Search
0 1 2 3 4 5
Data 1 2 4 5 8 9 Find 8
i jj
= 3
m = 2 j = 5
รอบที่ 2 m = 4
mm
หมายเหตุ: ตรวจดูว่าเจอรึยัง ถ้ายังไม่เจอก็ทําต่อ

Binary Search
0 1 2 3 4 5
Data 1 2 4 5 8 9 Find 8
i jj
= 3
m = 2 j = 5
รอบที่ 2 i = 3 m = 4 j = 4
รอบที่ 3 m = 3
mm

Binary Search
0 1 2 3 4 5
Data 1 2 4 5 8 9 Find 8
i jj
= 3
m = 2 j = 5
รอบที่ 2 i = 3 m = 4 j = 4
รอบที่ 3 i = 4 m = 3 j = 4
mm
หมายเหตุ: หยุด ถ้าใช่เจอ ถ้าไม่ใช่แสดงว่าไม่เจอ

Binary Search
Algorithm BinarySearch( data[n]:integer, find:integer )
i:=0, j:=n-1
while( i<j )
m:=
if data[m] < find then i:=m+1
else j:=m
if data[i] = find then pos:=I
else pos:= -1 {not found}
return pos
End Algorithm

Binary Search

Binary Search
0 1 2 3 4 5
Data 1 2 4 5 8 9 Find 8

Binary Search
เปรียบเทียบ Linear Binary
ข้อมูล 6 ตัว 6 รอบ รอบ
=
= 2.xxx รอบ
(Worse case คือ 3 รอบ)
ข้อมูล 100 ตัว 100 รอบ รอบ
=
= 6.xxx รอบ
เร็วกว่าเห็นๆ

Binary Search
• คราวที่แล้วเราเรียนเรื่อง Recursion ไปแล้ว ดังนั้น
ลองเอาความรู้ที่ได้มาประยุกต์ใช้กันดู

Binary Search
เราจะวนคิดไปเรื่อยๆ
ตรงนี้คือเงื่อนไขการจบ

Binary Search

Binary Search
• ช่วงข้อมูลในการพิจารณาคือ i และ j โดยมี
ตําแหน่งตรงกลางคือ m
• ดังนั้นเราเอาตําแหน่งกลางไปเทียบกับ find ได้เลย
• หากค่า find มากกว่าตําแหน่งตรงกลาง เราก็จะ
ทําครึ่งขวา โดยทําตั้งแต่ตําแหน่ง m + 1 จนถึง j
นั่นเอง (แสดงว่า find ไม่ได้อยู่ในซีกซ้าย จะอยู่ใน
ซีกขวานั่นเอง)

Binary Search
• สามารถเขียนฟังก์ชันเพิ่มเติมได้ในลักษณะนี้

Binary Search

Binary Search
• โดยเมื่อหาเจอจะต้อง Return ตําแหน่งที่พบใน
BinSearch โดยจะทําการเรียก BSRecur เพื่อใช้ใน
การหา ซึ่งจะส่งข้อมูลเริ่มต้นไปให้ นั่นคือ i = 0
และ j = n-1 นั่นเอง
• ผลสุดท้ายจะได้ค่า i ออกมา ถ้าเจอก็ได้ pos แต่
ถ้าไม่เจอก็ให้เป็นเลข -1

Binary Search
• เทคนิคการคิดลักษณะนี้มันจะตรงกับอัลกอริทึมที่
เรียกว่า Divide-and-Conquer (แบ่งและชนะ) ทํา
ให้การทํางานของโปรแกรมดีขึ้น
• ยังมีอัลกอริทึมอีกอันนึงคือ Merge Sort ซึ่งอันนี้ก็
ใช้ Divide-and-Conquer ด้วยเหมือนกัน

Select Sort

Select Sort
• แปลตรงๆ คือการเลือกไปเรียง
• แปลดีๆ คือการเลือกค่าที่ต้องการ เพื่อไปวางยัง
ตําแหน่งที่ถูกต้อง
0 1 2 3 4 5
Data 8 2 1 3 4 6

Select Sort
0 1 2 3 4 5
Data 8 2 1 3 4 6
• เราจะเรียกจากน้อยไปมาก
• ดังนั้นต้องเลือกค่าที่ต้องการไปไว้ในตําแหน่งที่
ถูกต้อง

Select Sort
0 1 2 3 4 5
Data 8 2 1 3 4 6
0 1 2 3 4 5
Data 8 2 1 3 4 6
วนหาค่าที่น้อยที่สุดให้ได้
ก่อนว่าอยู่ตรงไหน
จากนั้นค่อยจับมาใส่

Select Sort
0 1 2 3 4 5
Data 8 2 1 3 4 6
0 1 2 3 4 5
Data 1 2 8 3 4 6
เลือก 1 มาวางที่ตําแหน่ง 0
ดังนั้นสลับเลข 1 กับ 8
หมายเหตุ: วนหา 6 รอบ

Select Sort
0 1 2 3 4 5
Data 1 2 8 3 4 6
0 1 2 3 4 5
Data 1 2 8 3 4 6
ดูต่อว่าค่าที่เหลือมีอันไหน
น้อยสุดบ้าง ถ้ามีก็สลับเลย
(ถ้าไม่มีก็ไปต่อได้)

Select Sort
0 1 2 3 4 5
Data 1 2 8 3 4 6
0 1 2 3 4 5
Data 1 2 3 8 4 6

Select Sort
0 1 2 3 4 5
Data 1 2 3 8 4 6
0 1 2 3 4 5
Data 1 2 3 4 8 6

Select Sort
0 1 2 3 4 5
Data 1 2 3 4 8 6
0 1 2 3 4 5
Data 1 2 3 4 6 8

Select Sort
• แสดงว่าต้องมีการวนทั้งหมด 2 Loop ซ้อนกัน
• นั่นคือ O(n2) นั่นเอง

Select Sort
ต้องมี temp เพราะเดี๋ยว
จะมีการสลับค่าเกิดขึ้น

Select Sort
หาตําแหน่งที่มี
ข้อมูลน้อยที่สุด

Select Sort
เอาข้อมูลมาสลับ

Select Sort

Merge Sort

Merge Sort
1 2 1 8 6 5 4

Merge Sort
1 2 1 8 6 5 4
1 2 1 8 6 5 4

Merge Sort
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 2 1 8 6 5 4

Merge Sort
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 2 1 8 6 5 4

Merge Sort
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 1 2 6 8 4 5*

Merge Sort
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 1 2 6 8 4 5
1 1 2 4 5 6 8
*
*

Merge Sort
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 2 1 8 6 5 4
1 1 2 6 8 4 5
1 1 2 4 5 6 8
1 1 2 4 5 6 8
*
*
*

Merge Sort
Algorithm mergesort( T[n] )
if n > 1 then
u[0 … -1 ] := T[ 0 … -1]
v[0 … -1] := T[ … n-1]
mergesort( u )
mergesort( v )
merge( u, v, T )
End Algorithm
5 4
5 4
u v
T
แบ่งต่อไปเรื่อยๆ อีก
อีกอัลกอริทึมนึง

Merge Sort
Algorithm merge( u[m], v[n], T[m+n] )
i := 0, j := 0
for k := 0 to m+n-1
if i >= m then T[k] := v[j], j := j + 1
else if j >= n then T[k] := u[i], i := i + 1
else if u[i] < v[j] then T[k] := u[i], i := i + 1
else T[k] := v[j], j := j + 1
End Algorithm
5 4
5 4
u v
T

Merge Sort
ลองทําด้วยตัวเองดูนะครับ

Merge Sort

Divide-and-Conquer

Divide-and-Conquer
• ดังนั้น Divide-and-Conquer คือการแบ่งข้อมูล
(ปัญหาต่างๆ) ให้มีขนาดเล็กลง แล้วจึงแก้ไข
ปัญหาไปทีละอย่าง
• แล้วค่อยนําคําตอบจากส่วนเล็กๆ มาประกอบกัน
จนเป็นคําตอบของโจทย์ปัญหาทั้งหมดนั่นเอง
• ซึ่งทั้ง Binary Search และ Merge Sort ล้วนแต่ใช้
เทคนิคของ Divide-and-Conquer ทั้งสิ้นอ. กิตตินันท์ น้1อยมณี 66

(Big One) C Language - 10 เทคนิคอัลกอริทึมแบบ divide-and-conquer

More Related Content

What's hot

Similar to (Big One) C Language - 10 เทคนิคอัลกอริทึมแบบ divide-and-conquer

(Big One) C Language - 10 เทคนิคอัลกอริทึมแบบ divide-and-conquer