Phan 2 - Chia de Tri

PHÂN TÍCH VÀ THIẾT KẾ THUẬT TOÁN
ThS. Nguyễn Minh Đế

denm81@gmail.com; 0933605881 (ZALO)
Nội dung
1. Chiến lược chia để trị
2. Các bài toán thông dụng
Khoa Công Nghệ Thông Tin
 Tìm kiếm nhị phân

 Tính tổng của các phần tử trong mảng a có n số nguyên
 Nhân 2 số nguyên lớn
 Sắp xếp MergeSort
 Sắp xếp QuickSort
 Thuật toán nhân ma trận Strassen
3. Bài tập
2
1. Chiến lược chia để trị (Divide and Conquer)
• Là một trong những chiến lược nổi tiếng trong lập trình.
• Chia bài toán lớn thành các bài toán nhỏ
–Bài toán nhỏ đơn giản, giải trực tiếp
–Nếu không tiếp tục chia nhỏ bài toán con
• Gộp lời giải của các bài toán con để xây dựng lời giải bài
toán lớn ban đầu.
3
1. Chiến lược chia để trị
• Ý tưởng: chiến lược chia để trị gồm 3 bước cơ bản
– Chia: chia nhỏ vấn đề thành nhiều phần
– Trị: Giải một cách đệ quy từng phần

– Gộp: Kết hợp các giải pháp cho các vấn đề phụ thành giải pháp tổng
thể.
• Phương pháp phổ biến
– Chia bài toán có kích thước n thành hai phần bằng nhau có kích
thước n/2.
– Giải đệ quy hai phần.
– Gộp hai kết quả thành kết quả tổng thể trong thời gian tuyến tính.
4
1.Chiến lược chia để trị
• Sơ đồ kỹ thuật chia
để trị trong trường
hợp phổ biến
5
2. Các bài toán thông dụng
 Tìm nhị phân
 Tính tổng của các phần tử trong mảng a có n số nguyên
 Sắp xếp MergeSort

 Sắp xếp QuickSort
 Tìm kiếm nhị phân
 Nhân 2 số nguyên lớn
 Thuật toán nhân ma trận Strassen
…
6
2.4. Tìm kiếm nhị phân
 Mục tiêu: Tìm một phần tử trong dãy đã sắp xếp.
 Phương pháp
–Chia: Kiểm tra phần tử chính giữa

–Trị: Tìm kiếm trên 1 mảng con tương ứng (sử dụng đệ quy)
–Gộp: Kết hợp lời giải mỗi phần thành kết quả.
 Ví dụ: Cho dãy số sau đã sắp xếp tăng dần
2 5 7 10 11 16 18
Tìm số: 11?
9?
7
Cho M có n = 7 phần tử, left = 0 và right = 6 = n - 1 = l + r = 0 + 6
 Ví dụ:
2 5 7 10 11 16 18
 Minh họa thuật toán: tìm số 11
Mid-i = n/2 = 7/2

=3
2 5 7 10 11 16 18 Mmid = M[3] 10 < 11
left mid right
left = mid + 1 = 4 2 5 7 10 11 16 18 Mmid = 16 > 11

Right = 6 
Mid-i = (l+r)/2 = 5 left mid right
2 5 7 10 11 16 18 Mmid = 11 = 11
right = mid - 1
Mid-i = (4+4)/2 = left mid right
4
8
 Giải thuật
B0: First 1 ; Last  n // xét toàn đoạn M
B1: IF (First > Last) then// hết phạm vi tìm

Không tìm thấy và thực hiện Bkt
B2: Mid  (First + Last)/2 // xác định vị trí giữa
B3: IF (x = M[Mid]) then
Tìm thấy tại vị trí Mid và thực hiện Bkt
B4: IF (x < M[Mid]) then tìm đệ qui từ First đến Last = Mid – 1
B5: IF (x > M[Mid]) then tìm đệ qui từ First = Mid + 1 đến Last
Bkt: kết thúc
9
 Giải thuật không đệ qui
B0: First 1 ; Last  n-1 // xét toàn đoạn M
B1: IF (First > Last) then// hết phạm vi tìm

Không tìm thấy và thực hiện Bkt
B2: Mid  (First + Last)/2 // xác định vị trí giữa
B3: IF (x = M[Mid]) then
Tìm thấy tại vị trí Mid và thực hiện Bkt
B4: IF (x < M[Mid]) then Last = Mid – 1 // xác định lại mốc phải
Lặp B3 // thực hiện lặp
B5: IF (x > M[Mid]) then First = Mid + 1 // xác định lại mốc trái
Lặp B3 // thực hiện lặp
Bkt: kết thúc
10
 Thuật toán BinarySearch(A, n, x)  không đệ quy
//Input: Mảng A[n] tăng dần, x
//Output: Chỉ số của phần tử = x hoặc −1 nếu không tìm thấy
l = 0; r = n − 1;
while (l ≤ r){
m = (l + r)/2;
if (K = A[m]) return m;
else if (K < A[m])
r = m − 1;
else
l = m + 1;
}
return −1;
11
Tìm kiếm nhị phân: cài đặt với đệ qui
int RecBinarySearch (T M[], int First, int Last, T x){ //(T cho trước)
1. if (First > Last) return (-1); // phần neo
2. int Mid = (First + Last)/2; // vị trí giữa

3. if (x == M[Mid]) return (Mid); // thấy tại mid
4. if (x < M[Mid]) return (RecBinarySearch(M, First, Mid – 1, x));
// x nhỏ hơn vị trí mid, tìm từ mốc trái đến mid
else return(RecBinarySearch(M, Mid + 1, Last, x) }
// x lớn hơn vị trí mid, tìm từ mốc phải đến mid
5. return (RecBinarySearch(M, 0, n – 1, x)); // thực hiện đệ quy tìm kiếm
}
12
 Thuật toán BinarySearch(A, n, x)
//Input: Mảng A[n] tăng dần, x
//Output: Chỉ số của phần tử = x hoặc −1 nếu không tìm thấy
int BinarySearchDQ(int a[], int left, int right, int x)

{
if (left > right)
return -1;
int mid = (left + right) / 2;
if (a[mid] == x)
return mid;
if (a[mid] > x)
return BinarySearchDQ(a, left, mid - 1, x);
else
return BinarySearchDQ(a, mid + 1, right, x);
}
13
Thuật toán BinarySearch(A, n, x)

o Tính độ phức tạp?
T(n) = 1T(n/2) + O(1)
14
Tìm kiếm nhị phân: phân tích với đệ qui
• Trường hợp tốt nhất, phần tử ở giữa có giá trị x:
– Số phép gán: Gmin = 1
– Số phép so sánh: Smin = 2

• Trường hợp xấu nhất, không có phần tử nào có giá trị x:
– Số phép gán: Gmax = log2n+1
– Số phép so sánh: Smax = 3log2n+1
• Trung bình:
– Số phép gán: Gavg = (log2n)/2 + 1
– Số phép so sánh: Savg = (3log2n+3) / 2
15
Tìm kiếm nhị phân: phân tích không đệ qui
• Trường hợp tốt nhất, phần tử ở giữa có giá trị x:
– Số phép gán: Gmin = 3
– Số phép so sánh: Smin = 2

• Trường hợp xấu nhất, không có phần tử nào có giá trị x:
– Số phép gán: Gmax = 2log2n+4
– Số phép so sánh: Smax = 3log2n+1
• Trung bình:
– Số phép gán: Gavg = (log2n)/2 + 4
– Số phép so sánh: Savg = (3log2n+3) / 2
16
Tính tổng của các phần tử trong mảng a có n số
• Mục tiêu: Tính tổng các phần tử trong mảng 1 chiều
• Phương pháp:
– Chia: chia mảng thành hai mảng con.

– Trị: Tính tổng của mỗi mảng con bằng phương pháp đệ quy
– Gộp: Cộng giá trị đã tính cho 2 mảng con để được kết quả.
• Ví dụ:
a0 + a1 + …+ an−1 = (a0 + … + an/2−1) + (an/2 + … + an−1)
17
2.1. Tính tổng của các phần tử trong mảng a có n số
Cho M có n = 7 phần tử, left = 0 và right = 6 = n - 1 = l + r = 0 + 6
• Ví dụ:
Mid = (l + r)/2 = 3
1 4 7 3 5 2 6
Mảng–trái (l, Mid-1) = M(0, 2)
Sao chép Mảng–trái 3 5 2 6

Mảng–phải (Mid, r) = M(3, 6)
1 4 7
Sao chép Mảng–phải
Mid = (l + r)/2 = 1
1 4 7 3 5 2 6
Sao chép Mảng–trái 4 7 3 5 2 6
Mid = (l + r)/2 = 1
11 8 8
Sao chép Mảng–trái 12 16
28
• Thời gian thực thi đệ quy: T(n) = aT(n/b) + f(n)

18
• Thuật toán:
tinhTong(a, n)
{
if (n == 1)
return a[0];
saoChep a[0 .. n/2 - 1] vào b[0.. n/2 - 1];
saoChep a[n/2 .. n - 1] vào c[0.. n/2 - 1];
return tinhTong (b, n/2) + tinhTong(c, n - n/2);
}
19
• Thuật toán:
tinhTong(a, l, r)
{
if (l == r)// kiểm tra phép so sánh làm điểm neo
return a[0];
//tính lại l1 và r1
//tính lại l2 và r2
return tinhTong(a, l1, r1) + tinhTong(a, l2, r2);
}
20
2.3. Sắp xếp QuickSort
• Mục tiêu: Phân chia các phần tử của cấu trúc dãy dựa theo giá trị của
chúng và sắp xếp 1 4 7 3 5 2 6
• Phương pháp:
–Chia: Tìm một phần tử x (thường lấy phần tử giữa mảng),

phân hoạch mảng thành 2 mảng con: mỗi phần tử mảng con
bên trái nhỏ hơn hoặc bằng x, mỗi phần tử mảng con bên phải
lớn hơn x.
–Trị: Sắp xếp hai mảng con trái và phải bằng cách đệ quy
QuickSort.
–Gộp: Các mảng con được sắp xếp tại chỗ - không cần thực
hiện công việc nào để kết hợp chúng.
21
• Ý tưởng: M[0…n-1]  chia làm 2 phần  Chọn phần tử đứng

giữa dãy là x tại vị trí j
• Dãy 1: M[0].. M[j] có các phần tử mà giá trị không lớn hơn x
• Dãy 2: M[j]..M[n-1] có các phần tử mà giá trị không nhỏ hơn x
Kết quả M được phân thành 3 phần:
• M[k] < x , với k = 0..j
• dãy 2 đã có thứ tự,
• M[k] = x , với k = j+1...i-1 • dãy 1 và 3 chỉ có 1 phần tử
• M[k] > x , với k = i...n-1 thì chúng cũng đã có thứ tự,
•  M đã được sắp xếp
22
• Trình bày ví dụ minh họa, mảng M có 10 phần tử
• left = 0, right = 9  mid = 4, x = M[4] = 3
• Hoán vị các vị trí: (0, 8), (1, 6), (2, 4)

23
• Hoán vị các vị trí: (0, 8), (1, 6), (2, 4)
4
5
1
0
• Tự thực hiện các bước hoán vị
24
• Thuật toán Quicksort(A, l, r)
//Input: Mảng con của A[n] được xác định bởi l và r
//Output: Mảng con A[l, r] đã sắp xếp theo thứ tự tăng dần
if (l < r)
s = Partition(A, l, r); //s vị trí phân hoạch
Quicksort(A, l, s − 1);
Quicksort(A, s + 1, r); Partition(A, l, r){
x = A[r], i = l - l;
for (j = l; j <= r; j++)
A[l..r] if (A[j]  x)
i = i + 1;
8 swap(A[i], A[j]);
A[l..s - 1] A[s + 1..r] swap(A[i + 1], A[r]);
return i + 1;
Partition 8
}
<8 >8
25
• Thuật toán Quicksort(A, l, r)
//Input: Mảng con của A[n] được xác định bởi l và r
//Output: Mảng con A[l, r] đã sắp xếp theo thứ tự tăng dần
if (l < r)
s = Partition(A, l, r); //s vị trí phân hoạch
Quicksort(A, l, s − 1);
Quicksort(A, s + 1, r); Partition(A, l, r){
k = (l + r)/2, x = A[k];
do{
while (a[l] < x) l++;
A[l..r] while (a[r] > x) r--;
if (l < r)
8 swap(A[l], A[r]);
A[l..s - 1] A[s + 1..r]
l++; r--;
}while (l <= r);
Partition 8
return r;
<8 >8 }
26
• Ví dụ:
7 18 11 10 2 5 16
i=0 x j=6
7 18 11 10 2 5 16
i=1 x j=5
7 5 11 10 2 18 16
i=2 x j=4
7 5 2 10 11 18 16
j=3
i=3 x
7 5 2 10 11 18 16
27
• Ví dụ:
7 5 2 10 11 18 16
i x j
2 5 7 10 11 18 16
= =
02 i 5x j 27 10 11 18 16
= =
1 5 17 i i x j
2 10 11 16 18
== =
2 5 7 10
j
411 5 16 i618
= = 28
• Cài đặt thuật toán Quicksort(A, l, r)
QuickSort(int a[], int left, int right)

{
if (left < right)

{
int s = Partition1(a, left, right);
QuickSort(a, left, s - 1);
QuickSort(a, s + 1, right);
}
}
29
• Cài đặt thuật toán Quicksort(A, l, r)
Partition(int a[], int left, int right) {
int k = (left + right)/2, x = a[k], l = left, r = right;

do{
while (a[l] < x) l++;
while (a[r] > x) r--;
if (l < r)
{
swap(a[l], a[r]);
l++;
r--;
}
}while(l <= r);
return r;
} 30
• Đánh giá độ phức tạp?
– Thời gian thực thi QuickSort nhanh hay chậm phụ thuộc vào
việc phân vùng cân bằng hay không.
– Phân vùng xấu nhất: phân thành mảng có n phần tử và 1 mảng

có 0 phần tử.
T(n) = T(n – 1) + T(0) + O(n) = T(n – 1) + O(n)
– Phân vùng tốt nhất: phân thành 2 bài toán con, mỗi bài kích
thước ko quá n/2.
T(n) = 2T(n/2) + O(n)
– Phân vùng cân bằng:
– O(n * log(n))
31
2.2. Thuật toán MergeSort
• Mục tiêu: Sắp xếp n phần tử của M đã cho theo thứ tự tăng dần
• Phương pháp:
– Chia: chia mảng thành hai mảng con.

– Trị: Sắp xếp đệ quy từng mảng con
– Gộp: Gộp 2 mảng con để tạo thành mảng được sắp xếp
• Ví dụ:
32
• Ý tưởng:
33
• Ví dụ:
34
• Ví dụ minh họa gộp 2 mảng con

min min
A G L O R H I M S T
35

min
min
A G L O R H I M S T
A G
36

min
min
A G L O R H I M S T
A G H
37

min
min
A G L O R H I M S T
A G H I
38

min
min
A G L O R H I M S T
A G H I L
39

min
min
A G L O R H I M S T
A G H I L M
40

min
min
A G L O R H I M S T
A G H I L M O
41

min
min
A G L O R H I M S T
A G H I L M O R
42


min
A G L O R H I M S T
A G H I L M O R S
43


min
A G L O R H I M S T
A G H I L M O R S T
44

 
A G L O R H I M S T
A G H I L M O R S T
45
• Gộp như thế nào?

– So sánh tuyến tính
– Sử dụng bảng phụ

• Thực hiện gộp
– Duyệt phần tử nhỏ nhất trong mỗi mảng con đã sắp xếp.
– Chèn phần tử nhỏ nhất trong hai phần tử vào mảng phụ.
– Lặp lại cho đến khi hoàn thành.
46
• Thuật toán MergeSort(A, 0, n − 1)

//Input: Mảng A[n]
//Output: Mảng A[n] đã sắp xếp tăng dần

if (n > 1)
copy A[0..n/2 − 1] to B[0..n/2 − 1]
copy A[n/2..n − 1] to C[0..n/2 − 1]
Mergesort(B, 0, n/2 − 1])
Mergesort(C, 0, n/2 − 1])
Merge(B, C, A);
47
Bài toán số nguyên lớn
• Cộng 2 số nguyên có n chữ số
1 1 0 1 0 1 0 1
+ 0 1 1 1 1 1 0 1 1 1 0 1 0 1 0 1
1 0 1 0 1 0 0 1 0 * 0 1 1 1 1 1 0 1
1 1 0 1 0 1 0 1 0
0 0 0 0 0 0 0 0 0
• Nhân 2 số nguyên có n chữ số 1 1 0 1 0 1 0 1 0
1 1 0 1 0 1 0 1 0
1 1 0 1 0 1 0 1 0
1 1 0 1 0 1 0 1 0
1 1 0 1 0 1 0 1 0
0 0 0 0 0 0 0 0 0
0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 1 0
48
2.5. Thuật toán nhân 2 số nguyên lớn
• Mục tiêu: Thực hiện phép nhân 2 số nguyên có n chữ số.
• Phương pháp:
– Chia: Phân tích mỗi số nguyên

𝑥 = 2𝑛/2 𝑥1 + 𝑥0 y = 2𝑛/2 𝑦1 + 𝑦0
– Trị: Nhân bốn số nguyên có n/2 chữ số.
– Gộp: Cộng hai số nguyên có n/2 chữ số và thay đổi để có kết
quả.
𝑥𝑦 = 2𝑛/2 𝑥1 + 𝑥0 2𝑛/2 𝑦1 + 𝑦0
= 2𝑛 𝑥1 𝑦1 +T(n)
2𝑛/2 𝑥4T
𝑦
1 0n +
/2 
𝑥 𝑦
0 1 +
(n) 𝑥 𝑦

0 0 T(n)  (n 2
)
add, shift
• Thời gian thực hiện: recursive calls
49
2.5. Thuật toán nhân 2 số nguyên lớn - Karatsuba
• Mục tiêu: Thực hiện phép nhân 2 số nguyên có n chữ số.
• Phương pháp:
– Chia: Phân tích mỗi số nguyên: 𝑥 = 2𝑛/2 𝑥1 + 𝑥0 y = 2𝑛/2 𝑦1 + 𝑦0

– Trị: Cộng hai số nguyên có n/2 chữ số; nhân ba số nguyên có n/2 chữ số.
– Gộp: Cộng, trừ và dịch chuyển ½ số nguyên có chữ số để có kết quả.
𝑥𝑦 = 2𝑛 𝑥1 𝑦1 + 2𝑛/2 𝑥1 𝑦0 + 𝑥0 𝑦1 + 𝑥0 𝑦0
= 2𝑛 𝑥1 𝑦1 + 2𝑛/2 𝑥1 + 𝑥0 𝑦1 + 𝑦0 − 𝑥1 𝑦1 − 𝑥0 𝑦0 + 𝑥0 𝑦0
• Thời gian thực hiện: T(n)  T  n /2   T  n /2   T  1 n /2   (n)
recursive calls add, subtract, shift
log 2 3
 T(n)  O(n )  O(n1.585 )
50
Bài toán nhân ma trận
• Giả sử muốn nhân hai ma trận có kích thước N x N.

• Ví dụ: A x B = C.
𝐶11 𝐶12 𝐴11 𝐴12 𝐵11 𝐵12

=
𝐶21 𝐶22 𝐴21 𝐴22 𝐵21 𝐵22
• Thực hiện
– C11 = a11b11 + a12b21
– C12 = a11b12 + a12b22
Thực hiện bằng 8 phép nhân
– C21 = a21b11 + a22b21
– C22 = a21b12 + a22b22
51
Bài toán nhân ma trận
• Thuật toán
void matrix_mult (){
for (i = 1; i <= N; i++){
for (j = 1; j <= N; j++){

C[i][j] = 0;
for (k = 1; k <= N; k++)
C[i, j] = c[i][j] +
a[i][k] * b[k][j];
}
}
}
• Thời gian thực hiện N
Ci , j   ai ,k bk , j
k 1
N N N
Thus T ( N )   c  cN 3  O( N 3 )
i 1 j 1 k 1
52
2.6. Thuật toán nhân ma trận Strassen
• Mục tiêu: Nhân hai ma trận có kích thước N x N + giảm thời gian thực
hiện.
• Phương pháp:
– Chia: Chia A và B thành (n/2) x (n/2) ma trận con
– Trị: Thực hiên đệ quy 7 phép nhân (n/2) x (n/2) ma trận
– Gộp: Tạo ma trận C sử dụng + và – trên (n/2) x (n/2) ma trận con
53
• Ví dụ:
A  B = C
A0 A1 B0 B1 A0  B0 + A1  B2 A0  B1 + A1  B3
 =
A2 A3 B2 B3 A2  B0 + A3  B2 A2  B1 + A3  B3
54
• Ví dụ:
𝐶11 𝐶12 𝐴11 𝐴12 𝐵11 𝐵12
=
𝐶21 𝐶22 𝐴21 𝐴22 𝐵21 𝐵22
P1 = (A11+ A22) * (B11+B22)

P2 = (A21 + A22) * B11
C11 = P1 + P4 - P5 + P7
P3 = A11 * (B12 - B22)
C12 = P3 + P5
P4 = A22 * (B21 - B11)
C21 = P2 + P4
P5 = (A11 + A12) * B22
C22 = P1 + P3 - P2 + P6
P6 = (A21 - A11) * (B11 + B12)
P7 = (A12 - A22) * (B21 + B22)
55
• Thuật toán Strassen
void MatMul(int *A, int *B, int *R, int n){

if (n == 1) {
(*R) += (*A) * (*B);
}
else {
MatMul(A, B, R, n/4);
MatMul(A, B + (n/4), R + (n/4), n/4);
MatMul(A + 2 * (n/4), B, R + 2 * (n/4), n/4);
MatMul(A + 2 * (n/4), B + (n/4), R + 3 * (n/4), n/4);
MatMul(A + (n/4), B + 2 * (n/4), R, n/4);
MatMul(A + (n/4), B + 3 * (n/4), R + (n/4), n/4);
MatMul(A + 3 * (n/4), B + 2 * (n/4), R + 2 * (n/4), n/4);
MatMul(A + 3 * (n/4), B + 3 * (n/4), R + 3 * (n/4), n/4);
}
}
56
• Thời gian thực hiện
57
Bài tập
1. Sắp xếp sau theo thứ tự bảng chữ cái: E, X, A, M, P, L, E

a. Sử dụng thuật toán MergeSort.
b. Sử dụng thuật toán QuickSort.

2. Thực hiện sắp xếp một mảng 1 chiều a theo thứ tự giảm dần
a. Sử dụng thuật toán MergeSort.
b. Sử dụng thuật toán QuickSort.
58
Bài tập
Sử dụng kỹ thuật chia để trị thực hiện:
1. Tìm vị trí của phần tử lớn nhất trong mảng n số nguyên. Trong
trường hợp mảng có nhiều phần tử có giá trị lớn nhất thì đầu
ra của thuật toán là gì?
2. Tính an.
3. Tìm phần tử trung bình của mảng
4. Tìm dãy con có tổng lớn nhất
5. Thiết kế một thuật toán để sắp xếp các phần tử của một dãy n
số thực cho trước sao cho tất cả các phần tử âm của mảng
đứng trước tất cả các phần tử dương trong mảng.
59

Phan 2 - Chia de Tri

Uploaded by

Copyright:

Available Formats

You might also like

Phan 2 - Chia de Tri

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Phan 2 - Chia de Tri

Uploaded by

Copyright:

Available Formats

PHÂN TÍCH VÀ THIẾT KẾ THUẬT TOÁN

ThS. Nguyễn Minh Đế

 Tìm kiếm nhị phân

• Chia bài toán lớn thành các bài toán nhỏ

–Bài toán nhỏ đơn giản, giải trực tiếp

–Nếu không tiếp tục chia nhỏ bài toán con

– Trị: Giải một cách đệ quy từng phần

hợp phổ biến

 Sắp xếp MergeSort

–Chia: Kiểm tra phần tử chính giữa

Mid-i = n/2 = 7/2

left mid right

left = mid + 1 = 4 2 5 7 10 11 16 18 Mmid = 16 > 11

B1: IF (First > Last) then// hết phạm vi tìm

B1: IF (First > Last) then// hết phạm vi tìm

2. int Mid = (First + Last)/2; // vị trí giữa

//Output: Chỉ số của phần tử = x hoặc −1 nếu không tìm thấy

int BinarySearchDQ(int a[], int left, int right, int x)

Thuật toán BinarySearch(A, n, x)

T(n) = 1T(n/2) + O(1)

– Số phép so sánh: Smin = 2

– Số phép so sánh: Smin = 2

– Chia: chia mảng thành hai mảng con.

Sao chép Mảng–trái 3 5 2 6

• Thời gian thực thi đệ quy: T(n) = aT(n/b) + f(n)

–Chia: Tìm một phần tử x (thường lấy phần tử giữa mảng),

• Ý tưởng: M[0…n-1]  chia làm 2 phần  Chọn phần tử đứng

• left = 0, right = 9  mid = 4, x = M[4] = 3

• Hoán vị các vị trí: (0, 8), (1, 6), (2, 4)

• Tự thực hiện các bước hoán vị

QuickSort(int a[], int left, int right)

if (left < right)

int k = (left + right)/2, x = a[k], l = left, r = right;

– Phân vùng xấu nhất: phân thành mảng có n phần tử và 1 mảng

– Chia: chia mảng thành hai mảng con.

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Ví dụ minh họa gộp 2 mảng con

• Gộp như thế nào?

– Sử dụng bảng phụ

• Thuật toán MergeSort(A, 0, n − 1)

//Output: Mảng A[n] đã sắp xếp tăng dần

– Chia: Phân tích mỗi số nguyên

– Chia: Phân tích mỗi số nguyên: 𝑥 = 2𝑛/2 𝑥1 + 𝑥0 y = 2𝑛/2 𝑦1 + 𝑦0

• Giả sử muốn nhân hai ma trận có kích thước N x N.

𝐶11 𝐶12 𝐴11 𝐴12 𝐵11 𝐵12

for (j = 1; j <= N; j++){

𝐶21 𝐶22 𝐴21 𝐴22 𝐵21 𝐵22

P1 = (A11+ A22) * (B11+B22)

void MatMul(int *A, int *B, int *R, int n){

void MatMul(int A, int B, int *R, int n){