CTDLGT - CPP - Chuong - 3 - Sap Thu Tu

Chương 3
Sắp thứ tự
(Buổi 3, 4, 5)
Nội dung
Phân loại sắp thứ tự
Định nghĩa sắp thứ tự
Straight Insertion Sort
Straight Selection Sort
Interchange Sort
Bubble Sort
Heap Sort
Shell Sort
Quick Sort
Trường Đại học Bách Khoa Tp.HCM Cấu trúc dữ liệu và Giải thuật
NGUYỄN TRUNG TRỰC Chương 3. Sắp thứ tự
Khoa Khoa học và Kỹ thuật Máy tính
© 2015 2
Nội dung
Merge Sort
Radix Sort
© 2015 3
Sắp thứ tự
Có hai loại sắp thứ tự:
f Sắp thứ tự trong: (internal sorting) còn được gọi
là sắp thứ tự mảng, tất cả phần tử cần sắp thứ tự
phải ở trong bộ nhớ chính.
f Sắp thứ tự ngoài: (external sorting) còn được gọi
là sắp thứ tự tập tin, một số phần tử cần sắp thứ
tự ở trong bộ nhớ chính, các phần tử còn lại ở bộ
nhớ ngoài.
© 2015 4
Sắp thứ tự
Sắp thứ tự trong có ba nhóm phương pháp:
f Phương pháp xen vào: (Insertion) sắp thứ tự xen
vào trực tiếp (Straight Insertion Sort).
f Phương pháp chọn: (Selection) sắp thứ tự chọn
trực tiếp (Straight Selection Sort), sắp thứ tự đống
(Heap Sort).
f Phương pháp đổi chỗ: (Exchange) sắp thứ tự nổi
bọt (Bubble Sort), sắp thứ tự nhanh (Quick Sort),
sắp thứ tự đổi chỗ trực tiếp (Interchange Sort).
© 2015 5
Sắp thứ tự một dãy các phần tử a1, a2, …, an là
hoán vị các phần tử này thành một dãy ak1, ak2,
…, akn sao cho với một hàm thứ tự f cho trước
và α là một quan hệ thứ tự toàn phần thì điều
kiện sau đây sẽ được thỏa mãn:
f(ak1) α f(ak2) α … α f(akn)
f f(aki) là vùng khóa (key) của phần tử aki.
f α là phép so sánh “nhỏ hơn hoặc bằng”, kết quả của
sắp thứ tự là một dãy tăng dần (không giảm).
f α là phép so sánh “lớn hơn hoặc bằng”, kết quả của
sắp thứ tự là một dãy giảm dần (không tăng).
© 2015 6
Phương pháp sắp thứ tự là ổn định nếu thứ tự
trước – sau giữa các phần tử có cùng giá trị
khóa lúc trước và sau khi sắp thứ tự vẫn
không thay đổi.
Đánh giá các giải thuật sắp thứ tự dựa vào số
lần so sánh và số lần di chuyển của các phần
tử cần được sắp thứ tự.
© 2015 7
Insertion Sort
Phương pháp
f Xét dãy a0, a1, …, ai-1 đã có thứ tự: tìm vị trí thích
hợp để xen ai vào sao cho dãy a0, a1, …, ai có thứ
tự.
f Lặp lại cách làm trên với i = 1, .., n-1.
© 2015 8
Insertion Sort
Giải thuật:
for (int i = 1; i < n; i++)
{
Tìm vị trí thích hợp để xen a[i] vào dãy [0, i-1];
Xen a[i] vào vi trí này;
}
© 2015 9
Insertion Sort
có thứ tự
0 1 2 i-1 i
1 5 6 6 8 2
xen vào
0 1 2 i-1 i
1 2 5 6 6 8
có thứ tự
Hình 3.1. Phương pháp Insertion Sort
© 2015 10
Insertion Sort x 2
2 Hình 3.2. Xen số 2

vào dãy con bên
1 5 6 6 8 2
trái đã có thứ tự.
2
1 5 6 6 8
2
1 5 6 6 8
2
1 5 6 6 8
2
1 5 6 6 8
1 2 5 6 6 8
© 2015 11
6 8 1 5 6 2 7 4
Insertion Sort
6 8 1 5 6 2 7 4
Dãy có thứ tự
1 6 8 5 6 2 7 4
1 5 6 8 6 2 7 4
1 5 6 6 8 2 7 4
1 2 5 6 6 8 7 4
1 2 5 6 6 7 8 4
Hình 3.3. Sắp thứ tự dãy số

bằng Insertion Sort. 1 2 4 5 6 6 7 8
© 2015 12
Insertion Sort
void Insertion(int a[], int n)
{
for (int i = 1; i < n; i++)
{
int j = i - 1;
int x = a[i];
bool cont = true;
while ((j >= 0) && cont)
if (a[j] > x)
{
a[j+1] = a[j];
j--;
}
else
cont = false;
a[j+1] = x;
}
}
© 2015 13
Insertion Sort
Độ phức tạp
f Khi tìm vị trí xen vào của phần tử ai:
Số lần so sánh Ci nhiều nhất là i và ít nhất là 1.
Số lần di chuyển Mi là Ci + 2 (kể cả di chuyển ai).
f Trường hợp xấu nhất: Dãy ban đầu có thứ tự
ngược (giảm dần), số lần so sánh và số lần di
chuyển các phần tử là lớn nhất.
f Trường hợp tốt nhất: Dãy ban đầu có thứ tự thuận
(tăng dần), chỉ có n-1 lần so sánh, không có số lần
di chuyển các phần tử.
f Nếu dãy ban đầu đã có thứ tự thì vẫn lặp (n-1) lần.
© 2015 14
Insertion Sort
Độ phức tạp
f Phương pháp sắp thứ tự ổn định.
f Thời gian: T(n) = O(n )
2
© 2015 15
Selection Sort
Phương pháp
f Xét dãy ai, ai+1, …, an-1 : tìm akmin có khóa nhỏ nhất
và hoán đổi ai với akmin.
f Lặp lại cách làm trên với i = 0, .., n-2.
© 2015 16
Selection Sort
Giải thuật:
for (int i = 0; i < n-1; i++)
{
Tìm a[kmin] nhỏ nhất trong dãy [i, n-1]
Hoán đổi a[i] với a[kmin]
}
© 2015 17
Selection Sort
0 1 i n-1
1 2 6 6 5 8 7 4
có thứ tự kmin
0 1 i n-1
1 2 4 6 5 8 7 6
có thứ tự
Hình 3.4. Phương pháp Selection Sort
© 2015 18
6 8 1 5 6 2 7 4
Selection Sort
1 8 6 5 6 2 7 4
Dãy có thứ tự
1 2 6 5 6 8 7 4
1 2 4 5 6 8 7 6
1 2 4 5 6 8 7 6
1 2 4 5 6 8 7 6
1 2 4 5 6 6 7 8
Hình 3.5. Sắp thứ tự dãy số
bằng Selection Sort. 1 2 4 5 6 6 7 8
© 2015 19
Selection Sort
void Selection(int a[], int n)
{
for (int i = 0; i < n-1; i++)
{
// Tìm a[kmin] nhỏ nhất trong dãy [i, n-1]
int minval = a[i];
int kmin = i;
for (int j = i+1; j < n; j++)
if (minval > a[j])
{
minval = a[j];
kmin = j;
}
// Hoán đổi a[i] với a[kmin]
Swap(a[i], a[kmin]);
}
}
© 2015 20
Selection Sort
void Swap(int& x, int& y)
{
// Hoán đổi x với y
int temp = x;
x = y;
y = temp;
}
© 2015 21
Selection Sort
Độ phức tạp
f Khi tìm phần tử nhỏ nhất akmin trong dãy ai, ai+1, …,
an-1:
Số lần so sánh Ci là n – 1 – i.
Số lần di chuyển Mi là 3 (hoán đổi ai với akmin nếu i
≠ kmin).
ngược (giảm dần), số lần di chuyển các phần tử là
lớn nhất.
(tăng dần), không có số lần di chuyển các phần tử.
© 2015 22
Selection Sort
f Phương pháp sắp thứ tự không ổn định.
2
© 2015 23
Heap Sort
Dãy ai,…, aj,…, ak là một đống (heap) nếu với
mọi aj, a2(j+1), a2(j+1)-1 trong dãy thì:
aj ≥ a2(j+1)
và aj ≥ a2(j+1)-1
aj 9
a2(j+1)-1 5 8 a2(j+1)
Hình 3.6. Định nghĩa đống (heap)
© 2015 24
Heap Sort
a0 9
a1 5 8 a2
a3 3 a4 4 6 a5 7 a6
Hình 3.7. Ví dụ đống (heap)
© 2015 25
Heap Sort
Tính chất
f Dãy a0,…, ak là một đống thì a0 có khóa lớn nhất.
f Dãy ai,…, ak bất kỳ thì nửa cuối của dãy này là một
đống.
f Dãy ai,…, ak là một đống thì mọi dãy con của dãy
này là một đống.
f Dãy ai,…, ak có thứ tự (giảm dần) thì dãy này là
một đống.
f Dãy ai,…, ak là một đống thì dãy này chưa chắc có
thứ tự.
© 2015 26
Heap Sort
Phương pháp:
f Bước 1: Tạo dãy a0, a1,…, an-1 là một đống bắt đầu từ
nửa cuối của dãy này là một đống.
f Bước 2: Tạo dãy a0, a1,…, an-1 có thứ tự (tăng dần).
© 2015 27
Heap Sort
Heap
0 1 2 3 4 5 6 7
4 6 7 5 6 2 1 8
a0 so với a1 và a2 4 6 7 5 6 2 1 8
a2 so với a5 và a6 7 6 4 5 6 2 1 8
7 6 4 5 6 2 1 8
Hình 3.8. Sift(0, 7) để tạo heap a0.. a7 từ heap a1.. a7.

© 2015 28
Heap Sort
0 1 2 3 4 5 6 7 Heap
Sift(3, 7) 6 8 1 5 6 2 7 4
Sift(2, 7) 6 8 1 5 6 2 7 4
Sift(1, 7) 6 8 7 5 6 2 1 4
Sift(0, 7) 6 8 7 5 6 2 1 4
8 6 7 5 6 2 1 4
Hình 3.9. Bước 1 – Tạo heap ban đầu.

© 2015 29
Heap Sort
0 1 2 3 4 5 6 7
Heap
đổi 8 với 4 8 6 7 5 6 2 1 4
Dãy có thứ tự
Sift(0, 6) 4 6 7 5 6 2 1 8
đổi 7 với 1 7 6 4 5 6 2 1 8
Sift(0, 5) 1 6 4 5 6 2 7 8
đổi 6 với 2 6 6 4 5 1 2 7 8
Sift(0, 4) 2 6 4 5 1 6 7 8
đổi 6 với 1 6 5 4 2 1 6 7 8
Hình 3.9. Bước 2 – Tạo dãy có thứ tự.

© 2015 30
Heap Sort
0 1 2 3 4 5 6 7
Heap
Sift(0, 3) 1 5 4 2 6 6 7 8
Dãy thứ tự
đổi 5 với 1 5 2 4 1 6 6 7 8
Sift(0, 2) 1 2 4 5 6 6 7 8
đổi 4 với 1 4 2 1 5 6 6 7 8
Sift(0, 1) 1 2 4 5 6 6 7 8
đổi 2 với 1 2 1 4 5 6 6 7 8
1 2 4 5 6 6 7 8
Hình 3.9. Bước 2 – Tạo dãy có thứ tự.

© 2015 31
Heap Sort
void HeapSort(int a[], int n)
{
// Giai đoạn 1: tạo heap ban đầu
int k = n / 2 - 1;
for (int i = k; i >= 0; i--)
Sift(a, i, n-1);
// Giai đoạn 2: tạo mảng có thứ tự

for (int i = n-1; i > 0; i--)
{
Swap(a[0], a[i]);
Sift(a, 0, i-1);
}
}
© 2015 32
Heap Sort
void Sift(int a[], int p, int q)
{
int x = a[p];
int i = p;
int j = 2 * i + 1;
bool cont = true;
while ((j <= q) and cont)
{
if (j < q)
if (a[j] < a[j+1])
j = j + 1;
if (x < a[j])
{
a[i] = a[j];
i = j;
j = j * 2 + 1;
}
else
cont = false;
}
a[i] = x;
}
© 2015 33
Heap Sort
Độ phức tạp
thuận (tăng dần), số lần so sánh và số lần di
chuyển các phần tử là lớn nhất khi tạo đống ban
đầu. Ta cần n/2 bước để hoán vị các phần tử qua
log2(n/2), log2(n/2+1), …, log2(n-1) vị trí.
f Trường hợp tốt nhất: Dãy ban đầu có thứ tự
ngược (giảm dần), không có số lần di chuyển các
phần tử khi tạo đống ban đầu.
f Thời gian: T(n) = O(n.log2n)
© 2015 34
Bubble Sort
Sắp thứ tự nổi bọt có hai loại:
f Có dùng cờ
f Không dùng cờ
© 2015 35
Bubble Sort (không cờ)
Phương pháp
f Lặp (n-1) lần, với n là số phần tử của dãy.
f Ở mỗi bước lặp thứ i (i = n-1, … 1), duyệt toàn bộ
dãy từ trên xuống dưới (j = 0, …, i-1): nếu aj > aj+1
thì hoán đổi aj với aj+1
f Cuối mỗi bước lặp, ta tìm được phần tử có khóa
lớn kế tiếp di chuyển về phía cuối của dãy.
© 2015 36
Giải thuật:
for (i = n-1; i >= 1; i--)
for (j = 0; j <= i - 1; j++)
if (a[j] > a[j+1])
Hoán đổi a[j] với a[j+1];
© 2015 37
6 6 6 6 6 6 6 6
8 8 1 1 1 1 1 1
1 1 8 5 5 5 5 5
5 5 5 8 6 6 6 6
6 6 6 6 8 2 2 2
2 2 2 2 2 8 7 7
7 7 7 7 7 7 8 4
4 4 4 4 4 4 4 8
8 lớn nhất
Hình 3.10. Lần lặp đầu tiên của Bubble Sort.
© 2015 38
1
5
2 Chưa có thứ tự
6
4
6
7 Đã có thứ tự
8
Hình 3.11. Phương pháp Bubble Sort
© 2015 39
Lần 1 Lần 2 Lần 3 Lần 4 Lần 5 Lần 6 Lần 7

6 6 1 1 1 1 1 1
8 1 5 5 2 2 2 2
1 5 6 2 5 4 4 4
5 6 2 6 4 5 5 5
6 2 6 4 6 6 6 6
2 7 4 6 6 6 6 6
7 4 7 7 7 7 7 7
4 8 8 8 8 8 8 8
Hình 3.12. Sắp thứ tự dãy bằng Bubble Sort.
© 2015 40
void BubbleNoFlag(int a[], int n)
// Bubble Sort không cờ
{
for (int i = n-1; i >= 1; i--)
for (int j = 0; j <= i - 1; j++)
if (a[j] > a[j+1])
Swap(a[j], a[j+1]);
}
© 2015 41
(2) j = 0→i-1 0 0
1 1
j 9 j 5
j+1 5 j+1 9
(1) i = n-1→1 n-1 n-1
© 2015 42
Bubble Sort (có cờ)
Phương pháp
f Lặp nhiều lần cho đến khi không thay đổi cờ.
f Ở bước lặp thứ k, duyệt dãy a0,…, an-k: nếu aj > aj+1
thì hoán đổi aj với aj+1 và thay đổi cờ.
f Các phần tử có khóa lớn di chuyển về phía cuối
của dãy.
Nhận xét
f Số lần lặp tối đa là (n-1).
f Nếu dãy ban đầu đã có thứ tự thì chỉ cần lặp một
lần.
f Thời gian: T(n) = O(n )2
© 2015 43
flag = false flag = true
0 0
1 1
j 9 j 5
j+1 5 j+1 9
n-1 n-1
© 2015 44
6 6 1 1 1 1 1
8 1 5 5 2 2 2
1 5 6 2 5 4 4
5 6 2 6 4 5 5
6 2 6 4 6 6 6
2 7 4 6 6 6 6
7 4 7 7 7 7 7
4 8 8 8 8 8 8
flag = flag = flag = flag = flag = flag =
true true true true true false
Hình 3.15. Sắp thứ tự dãy bằng Bubble Sort.
© 2015 45
Giải thuật:
k = 1;
flag = true;
while (flag)
{
flag = false;
for (j = 0; j < n - k; j++)
if (a[j] > a[j+1])
{
flag = true;
}
k = k + 1;
}
© 2015 46
void BubbleWithFlag(int a[], int n)
// Bubble Sort có cờ
{
int k = 1;
bool flag = true;
while (flag)
{
flag = false;
for (int j = 0; j < n - k; j++)
if (a[j] > a[j+1])
{
Swap(a[j], a[j+1]);
flag = true;
}
k = k + 1;
}
}
© 2015 47
Bubble Sort (có cờ) – cải tiến
Giải thuật:
k = n – 1;
flag = true;
while (flag)
{
flag = false;
for (j = 0; j < k; j++)
if (a[j] > a[j+1])
{
flag = true;
// Ghi nhớ vị trí hoán đổi
i = j;
}
k = i;
}
© 2015 48
flag = false flag = true
0 0
1 1
j 9 j 5 i=j
j+1 5 j+1 9
n-1 n-1
Hình 3.16. Phương pháp Bubble Sort cải tiến
© 2015 49
1 1 1 1
5 2 2 2
2 5 k 4 4
6 4 5 5
4 6 6 6
8 k 7 7 7
7 8 8 8
9 9 9 9
flag = flag = flag =
true true false
Hình 3.17. Sắp thứ tự dãy bằng Bubble Sort cải tiến
© 2015 50
Bubble Sort
public void BubbleSort( )
{
int k, i;
bool flag = true;
k = n - 1;
while (flag)
{
flag = false;
for (int j = 0; j < k; j++)
if (a[j] > a[j+1])
{
Swap(a[j], a[j+1]);
flag = true;
i = j;
}
k = i;
}
}
© 2015 51
Bubble Sort
Độ phức tạp
f Phương pháp sắp thứ tự ổn định.
2
© 2015 52
Quick Sort
Phương pháp
f Chọn một phần tử của dãy có khóa là pivot.
f Phân hoạch (partition) dãy a0, a1, …, an-1 dựa vào
phần tử pivot:
y Di chuyển các phần tử có khóa lớn hơn hoặc
bằng pivot về phía cuối dãy.
y Di chuyển các phần tử có khóa nhỏ hơn hoặc
bằng pivot về phía đầu dãy.
© 2015 53
Quick Sort
i pivot j
7 5 2
ai ≥ pivot aj ≤ pivot
2 5 7
Hình 3.18. Phân hoạch một dãy

© 2015 54
Quick Sort
Giải thuật:
// Phân hoạch dãy a[first],…,a[last]
// pivot là phần tử chính giữa
i = first;
j = last;
pivot = a[(first + last) / 2];
while (i <= j)
{
Tìm a[i] >= pivot từ trái qua;
Tìm a[j] <= pivot từ phải qua;
if (i <= j)
{
Hoán đổi a[i] với a[j];
i++;
j--;
}
};
© 2015 55
Quick Sort
Phương pháp
f Phân hoạch có thể chia dãy a0, a1, …, an-1 thành ba
dãy con:
y Dãy con 1: chứa các phần tử có khóa nhỏ hơn
hoặc bằng pivot.
y Dãy con 2: chứa các phần tử có khóa bằng pivot.
y Dãy con 3: chứa các phần tử có khóa lớn hơn
hoặc bằng pivot.
f Tiếp tục thực hiện phân hoạch cho dãy con 1 và
dãy con 3 nếu mỗi dãy này có nhiều hơn một phần
tử.
© 2015 56
Quick Sort
0 1 2 3 4 5 6 7
pivot = 5 6 8 1 5 6 2 7 4
i j
4 8 1 5 6 2 7 6
i j
4 2 1 5 6 8 7 6
i j
ai ≤ pivot ai = pivot ai ≥ pivot
4 2 1 5 6 8 7 6
j i
Hình 3.19. Kết quả phân hoạch
© 2015 57
Quick Sort
void Partition(int a[], int p, int q)
{
int x = a[(p + q) / 2];
int i = p;
int j = q;
while (i <= j)
{
while (a[i] < x) i++;
while (a[j] > x) j--;
if (i <= j)
{
Swap(a[i], a[j]);
i++;
j--;
}
};
if (p < j)
Partition(a, p, j);
if (i < q)
Partition(a, i, q);
}
© 2015 58
Quick Sort
void QuickSort(int a[], int n)
{
// Phân hoạch dãy [0, n-1]
Partition(a, 0, n-1);
}
© 2015 59
Quick Sort
Độ phức tạp
f Trường hợp xấu nhất: Chọn pivot là khóa nhỏ
nhất hoặc lớn nhất của dãy. Phân hoạch chia dãy
ra làm hai dãy con. T(n) = O(n )
2
f Trường hợp tốt nhất: Chọn pivot là khóa chính

giữa của dãy có thứ tự. Phân hoạch chia dãy ra
làm ba dãy con. T(n) = O(n.log2n)
© 2015 60
Merge Sort
Phương pháp
f Trộn xen kẽ các phần tử của hai dãy có cùng thứ
tự a0, a1, …, am và b0, b1, …, bn đưa vào dãy c0, c1,
…, cm+n.
© 2015 61
Merge Sort
a
1 6 8
i c
1 2 4 5 6 6 7 8
b
k
2 4 5 6 7
Hình 3.20. Trộn dãy a và dãy b đưa vào dãy c
© 2015 62
Merge Sort Hình 3.21. Sắp thứ tự dãy bằng Merge Sort
8 6 1 5 6 2 7 9 4
8 6 1 5 6 2 7 9 4
8 6 1 5 6 2 7 9 4
8 6 1 5 6 2 7 9 4
6 8 1 5 2 6 9 4
4 9
4 7 9
1 5 6 8 2 4 6 7 9
1 2 4 5 6 6 7 8 9
© 2015 63
Merge Sort
void Merge(int a[], int temp[], int p, int t, int q)
// Trộn dãy a[p]..a[t-1] với dãy a[t]..a[q] đưa vào mảng temp
{
int i = p;
int k = t - 1;
int n = 0;
while ((p <= k) && (t <= q))
{
if (a[p] < a[t])
{
temp[n] = a[p];
p++;
}
else
{
temp[n] = a[t];
t++;
}
n++;
}
© 2015 64
Merge Sort
for (int j = p; j <= k; j++)
{
temp[n] = a[j];
n++;
}
for (int j = t; j <= q; j++)
{
temp[n] = a[j];
n++;
}
for (int j = 0; j < n; j++)
a[i+j] = temp[j];
}
© 2015 65
Merge Sort
void RecMergeSort(int a[], int temp[], int p, int q)
// Sắp thứ tự trộn dãy a[p]..a[q]
{
if (p < q)
{
int k = (p + q) / 2;
RecMergeSort(a, temp, p, k);
RecMergeSort(a, temp, k+1, q);
Merge(a, temp, p, k+1, q);
}
}
void MergeSort(int a[], int n)

{
int temp[n];
RecMergeSort(a, temp, 0, n-1);
}
© 2015 66
Merge Sort
Độ phức tạp
f Trộn dãy a có m phần tử và dãy b có n phần tử, ta
được dãy c có (m+n) phần tử.
f Sắp thứ tự một dãy có n phần tử thì phải dùng
thêm vùng nhớ tạm chứa n phần tử.
f Thời gian: T(n) = O(n.log2n)
© 2015 67
Radix Sort
Radix sort là một giải thuật sắp thứ tự không
cần so sánh (non-comparative sorting
algorithm) để sắp thứ tự các khóa nguyên bằng
cách gom nhóm các khóa theo các ký số riêng
biệt mà chúng có cùng trọng số (đơn vị, chục,
trăm, ngàn, …).
Vì số nguyên có thể biểu diễn chuỗi ký tự, do
đó Radix Sort không chỉ được dùng để sắp thứ
tự các số nguyên.
© 2015 68
Radix Sort
Có hai loại Radix Sort:
f Least significant digit (LSD) Radix Sort: xử lý
các số nguyên bắt đầu từ ký số có trọng số
nhỏ nhất đến ký số có trọng số lớn nhất.
f Most significant digit (MSD) Radix Sort: xử lý
các số nguyên bắt đầu từ ký số có trọng số
lớn nhất đến ký số có trọng số nhỏ nhất.
Độ phức tạp
f T(n) = O(d.n) với d là số ký số của số nguyên lớn
nhất của dãy a0, a1, …, an-1.
f T(n) = O(n.log2n)
© 2015 69
Radix Sort
Dãy số ban đầu: 170, 45, 75, 90, 802, 2, 24, 66
Xét vị trí hàng đơn vị:
Bucket 0: 170 90
Bucket 1:
Bucket 2: 802 2
Bucket 3:
Bucket 4: 24
Bucket 5: 45 75
Bucket 6: 66
Bucket 7:
Bucket 8:
Bucket 9:
Dãy số: 170 90 802 2 24 45 75 66
Hình 3.22. Sắp thứ dãy bằng Radix Sort
© 2015 70
Radix Sort
Dãy số: 170 90 802 2 24 45 75 66
Xét vị trí hàng chục:
Bucket 0: 802 2
Bucket 1:
Bucket 2: 24
Bucket 3:
Bucket 4: 45
Bucket 5:
Bucket 6: 66
Bucket 7: 170 75
Bucket 8:
Bucket 9: 90
Dãy số: 802 2 24 45 66 170 75 90
© 2015 71
Radix Sort
Dãy số: 802 2 24 45 66 170 75 90
Xét vị trí hàng trăm:
Bucket 0: 2 24 45 66 75 90
Bucket 1: 170
Bucket 2:
Bucket 3:
Bucket 4:
Bucket 5:
Bucket 6:
Bucket 7:
Bucket 8: 802
Bucket 9:
Dãy số có thứ tự: 2 24 45 66 75 90 170 802
© 2015 72
Radix Sort
void Radix(int a[], int n, int max)
// LSD Radix Sort
{
int BASE = 10; // cơ số 10
int bucket[BASE]; // mảng chứa số phần tử
int b[n];
// tìm giá trị lớn nhất của mảng a

int max = a[0];
for (int i = 1; i < n; i++)
if (a[i] > max)
max = a[i];
© 2015 73
Radix Sort
// xét các vị trí ký số
int x = 1;
while (max / x > 0)
{
// tính số phần tử của mỗi bucket
for (int i = 0; i < BASE; i++)
bucket[i] = 0;
for (int i = 0; i < n; i++)
bucket[(a[i] / x) % BASE]++;
for (int i = 1; i < BASE; i++)
bucket[i] = bucket[i] + bucket[i-1];
// đưa các phần tử vào các bucket
for (int i = n-1; i >= 0; i--)
{
bucket[(a[i] / x) % BASE]--;
b[bucket[(a[i] / x) % BASE]] = a[i];
}
© 2015 74
Radix Sort
// đưa các phần trong các bucket vào mảng a
for (int i = 0; i < n; i++)
a[i] = b[i];
x = x * BASE;
}
}
int main()
{
int n = 8;
int a[] = {170, 45, 75, 90, 802, 2, 24, 66};
Radix(a, n);
Display(a, n);
system("pause");
return 0;
}
© 2015 75
Interchange Sort
Một cặp giá trị (a, b) được gọi là nghịch thế nếu
a và b không thỏa điều kiện sắp thứ tự, ví dụ
đối với sắp thứ tự tăng dần thì a > b.
Phương pháp
f Duyệt tất cả các cặp (ai, aj) của dãy a0, a1, …, an-1,
nếu cặp (ai, aj) là nghịch thế thì hoán đổi ai với aj.
© 2015 76
Interchange Sort
0 1 2 3 4 5 6 7
6 8 1 5 6 2 7 4
6 8 1 5 6 2 7 4
1 8 6 5 6 2 7 4
1 8 6 5 6 2 7 4
1 8 6 5 6 2 7 4
1 8 6 5 6 2 7 4
1 nhỏ nhất 1 8 6 5 6 2 7 4
Hình 3.23. Một bước lặp của Interchange Sort

© 2015 77
Interchange Sort
0 1 2 3 4 5 6 7
6 8 1 5 6 2 7 4
1 8 6 5 6 2 7 4
1 2 8 6 6 5 7 4
1 2 4 8 6 6 7 5
1 2 4 5 8 6 7 6
1 2 4 5 6 8 7 6
1 2 4 5 6 6 8 7
1 2 4 5 6 6 7 8
Hình 3.24. Sắp thứ tự dãy bằng Interchange Sort

© 2015 78
Interchange Sort
Độ phức tạp
2
© 2015 79
Interchange Sort
void Interchange(int a[], int n)
{
for (int i = 0; i < n-1; i++)
for (int j = i+1; j < n; j++)
if (a[i] > a[j])
Swap(a[i], a[j]);
}
© 2015 80
Tổng kết
Ba nhóm sắp thứ tự:
f Xen vào: Insertion Sort
f Chọn: Selection Sort, Heap Sort, Radix Sort
f Đổi chỗ: Bubble Sort, Merge Sort, Quick Sort,
Interchange Sort
Độ phức tạp:
f Nhóm O(n ):
Insertion Sort, Selection Sort, Bubble
2
Sort, Interchange Sort

f Nhóm O(nlog2n): Heap Sort, Merge Sort, Quick
Sort, Radix Sort
© 2015 81
Bài tập
© 2015 82

CTDLGT - CPP - Chuong - 3 - Sap Thu Tu

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

CTDLGT - CPP - Chuong - 3 - Sap Thu Tu

Uploaded by

Copyright:

Available Formats

Chương 3

2 Hình 3.2. Xen số 2

Hình 3.3. Sắp thứ tự dãy số

Hình 3.4. Phương pháp Selection Sort

Hình 3.6. Định nghĩa đống (heap)

Hình 3.7. Ví dụ đống (heap)

Hình 3.8. Sift(0, 7) để tạo heap a0.. a7 từ heap a1.. a7.

Hình 3.9. Bước 1 – Tạo heap ban đầu.

Hình 3.9. Bước 2 – Tạo dãy có thứ tự.

Hình 3.9. Bước 2 – Tạo dãy có thứ tự.

// Giai đoạn 2: tạo mảng có thứ tự

Hình 3.10. Lần lặp đầu tiên của Bubble Sort.

Hình 3.11. Phương pháp Bubble Sort

Lần 1 Lần 2 Lần 3 Lần 4 Lần 5 Lần 6 Lần 7

Hình 3.12. Sắp thứ tự dãy bằng Bubble Sort.

(1) i = n-1→1 n-1 n-1

Hình 3.13. Phương pháp Bubble Sort

Hình 3.14. Phương pháp Bubble Sort

Hình 3.15. Sắp thứ tự dãy bằng Bubble Sort.

Hình 3.16. Phương pháp Bubble Sort cải tiến

Hình 3.18. Phân hoạch một dãy

f Trường hợp tốt nhất: Chọn pivot là khóa chính

Hình 3.20. Trộn dãy a và dãy b đưa vào dãy c

void MergeSort(int a[], int n)

Hình 3.22. Sắp thứ dãy bằng Radix Sort

Hình 3.22. Sắp thứ dãy bằng Radix Sort

Hình 3.22. Sắp thứ dãy bằng Radix Sort

// tìm giá trị lớn nhất của mảng a

Hình 3.23. Một bước lặp của Interchange Sort

Hình 3.24. Sắp thứ tự dãy bằng Interchange Sort

Sort, Interchange Sort

You might also like