sap xep

• Cứ như vậy, các bức thư sẽ được trao đến tay người nhận một cách có hệ thống mà công việc sắp xếp thư không quá nặng cách có hệ thống mà công việc sắp xếp thư không quá nặng.. Ngược lạ[r]

(1)

Chương 2

Các giải thuật tìm kiếm

và sắp thứ tự

(2)

2.1 Giới thiệu chung

• Trong hTrong hầầu hu hếết ht hệệ llưưu tru trữữ, qu, quảản lý dn lý dữữ liliệệu, thaou, thao tác tìm kiếm thường thực để khai thác thơng tin

• Do hệ thống thông tin thường phải lưu trữ khối lượng dg ữ liệu đáng kg ể, nên việc xây dy ựng cácg giải thuật cho phép tìm kiếm nhanh có ý nghĩa lớn

(3)

2.1 Giới thiệu chung

• Có nhiều giải thuật tìm kiếm xếp

• Mức độ hiệu giải thuật phụ thuộc vào tính chất cấu trúc liệu cụ thể mà tác động tính chất cấu trúc liệu cụ thể mà tác động

đến

• Dữ liệu lưu trữ chủ yếu nhớ

• Dữ liệu lưu trữ chủ yếu nhớ nhớ phụ, đặc điểm khác thiết bị

(4)

2.2 Các giải thuật tìm kiếm Bài tốn:

Tìm vị trí xuất phần tử có giá trị x danh sách đặc a

Input:

- Một dãy số nguyên a0, a1, ,an-1 i t [ 1]

int a[n-1];

- Khoá cần tìm x

int x; int x;

Output:

(5)

2.2 Các giải thuật tìm kiếm

2 Tìm kiếm tuyến tính 2.2.1 Tìm kiếm tuyến tính

Lần lượt so sánh x với phần tử mảng bắt đầu

Ý tưởng:

(6)

Thuật tốn:

Bước 1: Cho biến i giá trị khởi đầu

Bước 2: So sánh x với a[i] x = a[i] sang bước Thuật tốn:

Bước 2: So sánh x với a[i], x a[i] sang bước 3, không sang bước

B ớ 3 Kết l ậ “Tì thấ ” Kết thú Bước 3: Kết luận “Tìm thấy” Kết thúc Bước 4: Tăng giá trị i thêm đơn vị

(7)

2 Tìm kiếm tuyến tính

Ví dụ:

2.2.1 Tìm kiếm tuyến tính

Cho dãy số a

12 15

Ví dụ:

(8)

• i =

i

(9)

Cài đặt:

Cài đặt:

int LinearSearch(int a[],int n,int x) {

int i=0;

int i=0; while(i<n) {

ầ

if (a[i]==x) return i; // a[i] phần tử có khóa x i++;

} }

(10)

Nhận xét: Nhận xét:

Thuật tốn có điểm hạn chế: phải kiểm tra lần vòng lặp

lần vòng lặp

⇒ Khắc phục:

ầ

Sử dụng kỹ thuật phần tử “lính canh”, nghĩa ta cho thêm phần tử a[n]=x, vậy, bảo đảm

ấ

(11)

Cài đặt: Cài đặt:

int LinearSearch(int a[],int n,int x) {

int i=0;

int i=0; a[n]=x;

while(x!=a[i]) i++;

if (i==n)

returnetu -1; ; // tìm h// tìm hếết mt mảảng nhng nhưưng khơng có xng khơng có x

else

return i; // tìm thấy x vị trí i }

(12)

Đánh giá: Đánh giá:

(13)

• Giải thuật tìm tuyến tính khơng phụ thuộc vào thứ

tự ủ hầ tử t d h h d ậ đâ tự phần tử danh sách, phương pháp tổng quát để tìm kiếm danh sách

danh sách

• Đối với mảng có thứ tự thuật tốn khơng tối

ưu khơng tận dụng tính chất có thứ tự

(14)

2 2 Tìm kiếm nhị phân 2.2.2 Tìm kiếm nhị phân

Đối với dãy có thứ tự (giả sử thứ tự

) hầ d h

tăng), phần tử dãy có quan hệ ai -1 ≤ ai ≤ ai+1

Nếu x > ai x xuất

đoạn [a[ i+1i+1 ,an-1n 1] c] dãy.y

Nếu x < ai x xuất

đoạn [a0 ai 1] dãy

(15)

Ý tưởng:

(16)

Thuật tốn: Thuật tốn:

Bước 1: Khởi tạo left = 0, right = n -

Bước 2: Xác định phần tử giữa: mid = (left + right)/2

Bước 3: So sánh x với a[mid] Nếu x = a[mid] sang

Bước 3: So sánh x với a[mid] Nếu x a[mid] sang bước 4, khơng sang bước

ế l hấ ế h

Bước 4: Kết luận “Tìm thấy” Kết thúc

(17)

Thuật tốn: Thuật tốn:

Bước 6: Giới hạn khơng gian tìm kiếm: right = mid -1, sang bước

Bước 7: Giới hạn khơng gian tìm kiếm: left = mid + 1,

Bước 7: Giới hạn không gian tìm kiếm: left mid 1, sang bước

ế l f i h b kh h l i

(18)

Ví dụ: Ví dụ:

Cho dãy số a gồm phần tử:

1 12 15

ầ

(19)

(20)

(21)

Cài đặt:

i t Bi S h(i t [] i t i t )

int BinarySearch(int a[],int n,int x) {

int left = 0, right = n-1, mid;

do do

{

mid = (left + right)/2;

if (x == a[mid])

ấ

( [ ])

return mid; //Tìm thấy x mid

if (x<a[mid])

right = mid -1;

l else

left = mid +1;

} while (left <= right);

return -1; // dãy khơng có x

(22)

(23)

• Giải thuật dựa vào thứ tự phần tử

ả để đị h hướ iệ ắ ế ê khô thể mảng để định hướng việc xếp nên áp dụng cho trường hợp, áp dụng cho dãy có thứ tự

những dãy có thứ tự

• Giải thuật tìm nhị phân tiết kiệm thời gian nhiều so với giải thuật tìm tuyến tính

nhiều so với giải thuật tìm tuyến tính

(24)

• Khi muốn áp dụng giải thuật tìm nhị phân cần phải ét đế thời i ắ ế dã ố để thỏ điề kiệ

xét đến thời gian xếp dãy số để thỏa điều kiện dãy số có thứ tự Thời gian không nhỏ, dãy số biến động cần phải tiến hành xếp lại ⇒ dãy số biến động cần phải tiến hành xếp lại ⇒ khuyết điểm cho giải thuật tìm nhị phân

(25)

2.3 Các giải thuật sắp xếp nội

2 1 Định nghĩa toán sắp xếp 2.3.1. Định nghĩa toán sắp xếp

Sắp xếp trình xử lý danh sách phần tử

(hoặc mẫu tin) để đặt chúng theo thứ tự thỏa mãn mộột tiêu chuẩn dựựa nộội dung thơngg g tin lưu giữ phần tử

Lưu ý: Thứ tự đề cập thứ tự tổng

Lưu ý: Thứ tự đề cập thứ tự tổng quát

Ví dụ: Hãy định nghĩa thứ tự để dãy số sau

Ví dụ: Hãy định nghĩa thứ tự để dãy số sau dãy tăng theo thứ tự

1 3 5 7 22 20 10 6

(26)

2 1 Định nghĩa toán sắp xếp 2.3.1. Định nghĩa toán sắp xếp

Xét mảng số a0 a1 a Khái niệm “NGHỊCH THẾ”

Xét mảng số a0, a1, … an

Nếu có i<j ai > aj, ta gọi nghịch Mả h ắ ế ẽ ó hị h hế

Mảng chưa xếp có nghịch

(27)

2 Các phương pháp sắp xếp thông dụng

l i Phứ t h

2.3.2 Các phương pháp sắp xếp thơng dụng

• Selection sort

• Insertion sort

• Interchange sort

• Shell sort

• Heap sort Q i k

Phức tạp Hiệu cao

• Interchange sort

• Bubble sort

• Shaker sort

• Quick sort

• Merge sort

• Radix sort

Shaker sort

• Binary Insertion sort

• Radix sort

• …

Lớp thuật tốn Đơn giản,

Chi phí cao

(28)

2 3 Phương pháp chọn trực tiếp

2.3.3 Phương pháp chọn trực tiếp – Selection sort

Ý tưởng:

- Chọn phần tử nhỏ đặt vào vị trí

Ch hầ tử hỏ hất t ố hầ tử ò - Chọn phần tử nhỏ số n - phần tử cịn lại đặt vào vị trí thứ

- Lặp lại trình mảng phần tử

(29)

Thuật toán:

Bước 1: Khởi tạo i =

Bước 2: Khởi đầu = i, j = i +

Bước 3: Nếu a[j] < a[min] = j, khơng sang bước

sang bước

(30)

Thuật toán:

ế ế

Bước 5: Nếu j < n quay lại bước 3, khơng sang bước

Bước 6: Đổi chỗ a[min] a [i], tăng i lên đơn vị

Bước 7: Nếu i < n quay lại bước khơng

(31)

Find MinPos(0, 7) Swap(ai, amin)

min

1 2 3 4 5 6 7

0

2 8 5 1 6 4 15

12

(32)

2 8 12 6 4 1

1

min

1 2 3 4 5 6 7

0

2 8 5 12 6 4 15

1

(33)

2 4 5 12 6 8 15

1

min

1 2 3 4 5 6 7

0

2 4 5 12 6 8 15

1

(34)

min

1 2 3 4 5 6 7

0

2 4 5 12 6 8 15

1

(35)

min

1 2 3 4 5 6 7

0

2 4 5 6 12 8 15

1

(36)

min

1 2 3 4 5 6 7

0

2 4 5 6 8 12 15

1 12 15

(37)

void SelectionSort(int a[],int n) {

Cài đặt:

{

int min; // số phần tử nhỏ dãy hành

for (int i=0; i<n-1 ; i++) {

{

min = i;

for(int j = i+1; j < n ; j++)

if (a[j] < a[min])

min = j; // ghi nhận vị trí phần tử nhỏ nhất

if (min != i)

swap(a[min] a[i]);

(38)

Đánh giá:

Số lần hoán vị (một hoán vị phép gán) phụ

h ì h b đầ d ố

(39)

Đánh giá:

Ở lượt thứ i, cần (n-i) lần so sánh để xác định phần tử

h hấ hi hà h nhỏ hành

Số lượng phép so sánh không phụ thuộc vào tình trạng dãy số ban đầu

của dãy số ban đầu

(40)

2 4 Phương pháp chèn trực tiếp

2.3.4 Phương pháp chèn trực tiếp – Insertion sort

Ý ở

Ý tưởng:

-Tại bước thứ i phần tử từ a[0] đến a[i-1] có thứ

tự tăng dần

- Đầu tiên ta bắt đầu với i = (a[0] không c( [ ] g ần sắp)p)

- Tìm vị trí thích hợp để chèn a[1] vào đoạn a[0]…a[1]

Kế tiế tì ị t í thí h h để hè [2] đ

- Kế tiếp, tìm vị trí thích hợp để chèn a[2] vào đoạn a[0]…a[2]

(41)

Th ậ á

Thuật toán:

- Bước 1: Khởi tạo i =1

- Bước 2: pos = i -1, x = a[i]

- Bước 3: Nếu x < a[pos] sang b[p ] g ước khơng sangg g bước

B ớ 4 Dời [ ] hải [ +1] [ ] iả

(42)

Th ậ á

Thuật toán:

- Bước 5: Nếu pos ≥ quay lại bước 3, không sang bước

- Bước 6: Gán a[pos+1] = x, t[p ] , ăng i thêm 1g đơn vịị

(43)

Ví dụ:

1 2 3 4 5 6 7

0

2 8 5 1 6 4 15

(44)

Insert a1 into (0, 1)

2 8 5 1 6 4 15

12

1 2 3 4 5 6 7

0 pos

2 2 8 5 1 6 4 15

122

i

(45)

Insert a2 into (0, 2)

1 2 3 4 5 6 7

0

pos 8

12 8 5 1 6 4 15

2 8

i

(46)

Insert a3 into (0, 3)

8 12 5 1 6 4 15

2

1 2 3 4 5 6 7

0 pos

8 12 5 1 6 4 15

2 5

i

(47)

Insert a4 into (0, 4)

5 8 12 1 6 4 15

2

1 2 3 4 5 6 7

0

pos

1 5 8 12 1 6 4 15

21

i

(48)

Insert a5 into (0, 5)

2 5 8 12 6 4 15

1

1 2 3 4 5 6 7

0 pos

6

2 5 8 12 6 4 15

1 6

i

(49)

Insert a6 into (0, 6)

1 2 3 4 5 6 7

0 pos

2 5 6 8 12 4 15

1 4

i

(50)

Insert a7 into (0, 7)

1 2 3 4 5 6 7

0 pos

2 4 5 6 8 12 15

1 15

i

(51)

pos

1 2 3 4 5 6 7

0

2 4 5 6 8 12 15

(52)

Cài đặ Cài đặt:

void InsertionSort(int a[],int n) {

{

int pos;

int x ; //lưu trữ a[i] tránh bị ghi đè dời chỗ phần tử.

for(int i=1;i<n;i++) //đoạn a[0] đã sắp

for(int i=1;i<n;i++) //đoạn a[0] sắp {

x = a[i];

for(pos=i;(pos>0)&&(a[pos-1]>x);pos ) a[pos] = a[pos-1];

(53)

Nhậ é

Nhận xét:

- Khi tìm vị trí thích hợp để chèn a[i] vào đoạn a[0] đến a[i-1] đoạn Ỵ sử dụng giải thuật tìm 1], đoạn Ỵ sử dụng giải thuật tìm nhị phân để thực việc tìm vị trí pos Ỵ giải thuật xếp chèn nhị phân Binary Insertion Sort

Lưu ý: Chèn nhị phân chỉ làm giảm số lần so sánh, không làm giảm số lần dời chỗ.

(54)

Cài đặt Binary Insertion Sort: Cài đặt Binary Insertion Sort:

void BInsertionSort(int a[],int n)

{ int l,r,m,i;

i t //l t ữ iá t ị [i] t h bị hi đè dời hỗ á hầ tử int x; //lưu trữ giá trị a[i] tránh bị ghi đè dời chỗ phần tử.

for(int i=1;i<n;i++)

{ x = a[i]; l = 0; r = i-1;

while(l<=r) // tìm vị trí chèn x

while(l<=r) // tìm vị trí chèn x

{ m = (l+r)/2; // tìm vị trí thích hợp m

if(x < a[m]) r = m-1;

else l = m+1; }

for(int j = i ; j >l ; j )

(55)

- Các phép so sánh xảy vịng lặp tìm vị trí thích hợp pos Mỗi lần xác định vị trí pos xét khơng thích hợp Î dời

ầ ế

chỗ phần tử a[pos-1] đến vị trí pos

(56)

2 Phương pháp đổi chỗ trực tiếp

2.3.5 Phương pháp đổi chỗ trực tiếp – Interchange sort

Nhận xét:

Để xếp dãy số, ta xét nghịch có Ý tưởng:

ể ếp ộ dãy số, a có ể é g ịc ế có dãy làm triệt tiêu dần chúng

Ý tưởng:

- Xuất phát từ đầu dãy, tìm tất nghịch chứa phần tử triệt tiêu chúng cách đổi chỗ phần tử tử này, triệt tiêu chúng cách đổi chỗ phần tử với phần tử tương ứng cặp nghịch

(57)

Th ậ á

Thuật toán:

- Bước 1: Khởi tạo i = // bắt đầu từ đầu dãy

- Bước 2: j = i+1; //tìm cặp phần tử a[j] < a[i], j>i

- Bước 3: Trong j < n thg j ựực hiệện

• Nếu a[j]<a[i]: a[i]↔a[j];

• j = j+1; - Bước 4: i = i+1;

• Nếu i < n-1: Lặp lại Bước

(58)

Ví dụ:

j

2 8 5 1 6 4 15

12

1 2 3 4 5 6 7

0 j

1 2 8 5 1 6 4 15

12

i

1

(59)

j

12 8 5 2 6 4 15

1

1 2 3 4 5 6 7

0 j

2

12 8 5 2 6 4 15

1

i

2

(60)

j

2 12 8 5 6 4 15

1

1 2 3 4 5 6 7

0 j

4

2 12 8 5 6 4 15

1

i

4

(61)

j

2 4 12 8 6 5 15

1

1 2 3 4 5 6 7

0 j

5

2 4 12 8 6 5 15

1

i

5

(62)

2 4 5 6 8 12 15

1

1 2 3 4 5 6 7

0

2 4 5 6 8 12 15

(63)

Cài đặ

Cài đặt:

void InterchangeSort(int a[], int n) {

{

int i, j;

for (i = ; i<n-1 ; i++)

for (j =i+1; j < n ; j++)

for (j i+1; j < n ; j++)

if(a[j]< a[i]) //nếu có nghịch đổi chỗ

(64)

Đánh giá:

- Số lượng phép so sánh xảy khơng phụ thuộc vào tình trạng dãy số ban đầu

trạng dãy số ban đầu

- Số lượng phép hoán vị thực tùy thuộc vào kết so sánh

(65)

2 Phương pháp nổi bọt Bubble sort 2.3.6 Phương pháp nổi bọt – Bubble sort

Ý tưởng: Ý tưởng:

- Đưa dần phần tử có khóa (giá trị) nhỏ phía trước

trước

- Xuất phát từ cuối (đầu) dãy, đổi chỗ cặp phần tử kế

cận để đưa phần tử nhỏ (lớn) cặp phần tử cận để đưa phần tử nhỏ (lớn) cặp phần tử vị trí đầu (cuối) dãy hành, sau khơng xét đến bước

- Ở lần xử lý thứ i có vị trí đầu dãy i

- Lặp lại xử lý khơng cịn cặp phần tử

(66)

2 Phương pháp nổi bọt Bubble sort

Th ậ á

2.3.6 Phương pháp nổi bọt – Bubble sort

Thuật toán:

- Bước 1: Khởi tạo i =0

- Bước 2: j = n-1; //Duyệt từ cuối dãy ngược về vị trí i

- Bước 3: Trong j > i thg j ựực hiệện

• Nếu a[j]<a[j-1]: a[j]↔a[j-1]; //xét cặp phần tử kế cận

• j = j-1;

- Bước 4: i = i+1; // lần xử lý kế tiếp

• Nếu i = n-1: Dừng // Hết dãy

(67)

Ví dụ:

j

2 8 5 1 6 4 15

12

1 2 3 4 5 6 7

0 j

1

(68)

j

12 2 8 5 4 6 15

1

1 2 3 4 5 6 7

0 j

2

(69)

j

2 12 4 8 5 6 15

1

1 2 3 4 5 6 7

0 j

4

(70)

j

2 4 12 8 5 6 15

1

1 2 3 4 5 6 7

0 j

5

(71)

j

2 4 5 12 8 6 15

1

1 2 3 4 5 6 7

0 j

6

(72)

j

2 4 5 6 12 8 15

1

1 2 3 4 5 6 7

0 j

8

(73)

j

2 4 5 6 8 12 15

1

1 2 3 4 5 6 7

0 j

15 12

(74)

Cài đặ

Cài đặt:

void BubbleSort(int a[], int n) {

int i, j;

for (i = ; i<n-1 ; i++)

for (j =n-1; j>i ; j )

if(a[j]< a[j-1])

swap(a[j], a[j-1]);

(75)

Đánh giá:

- Số lượng phép so sánh xảy khơng phụ thuộc vào tình trạng dãy số ban đầu

trạng dãy số ban đầu

- Số lượng phép hoán vị thực tùy thuộc vào kết so sánh

(76)

Đánh giá:

Khuyết điểm:

- Không nhận diện tình trạng dãy có thứ tự hay - Khơng nhận diện tình trạng dãy có thứ tự hay có thứ tự phần

(77)

Cải tiến:

Giải thuật ShakerSort:

- DDựựa nguyên ta nguyên tắắcc đổđổi chi chỗỗ trtrựực tic tiếếpp

- Tìm cách khắc phục nhược điểm BubleSort

Trong lần xếp, duyệt mảng theo lượt từ phía khác :

o Lượt đi: đẩy phần tử nhỏ đầu mảng L t ề đẩ hầ tử lớ ề ối ả

o Lượt về: đẩy phần tử lớn cuối mảng

Ghi nhận lại đoạn xếp nhằm tiết kiệm phép so sánh thừa

(78)

Cải tiến:

- Bước 1: l = 0; r = n-1; //từ l đến r là đoạn cần được xếp

k = n-1; // ghi nhận lại vị trí k xảy hoán vị sau cùng để làm cơ sở thu hẹp đoạn l đến r

Bước 2:

- Bước 2:

Bước 2a: j = r ; // đẩy phần tử nhỏ về đầu mảng

Trong (j > l) :

Nếu a[j]<a[j-1]: a[j] ↔ a[j-1]; k = j; //lưu lại nơi xảy hoán vị j = j 1;

(79)

Cải tiến:

- Bước 2:

ẩ ầ ề ố

Bước 2b: j = l ; // đẩy phần tử lớn về cuối mảng

Trong (j < r):

Nếu a[j]>a[j+1]: a[j] ↔ a[j+1]; Nếu a[j]>a[j+1]: a[j] ↔ a[j+1]; k = j;//lưu lại nơi xảy hoán vị j = j+1;

r = k; //loại bớt phần tử có thứ tự ở cuối dãy

(80)

2 Sắp xếp Heap sort

hi hầ h hấ b i h

2.3.7 Sắp xếp –Heap sort

• Khi tìm phần tử nhỏ bước i, phương pháp xếp chọn trực tiếp không tận dụng

đ hơ i đ ó đ d

được thơng tin có phép so sánh bước i-1

• Giải thuật Heap Sort khắc phục nhược điểm cách chọn cấu trúc

liệu cho phép tích lũy thơng tin so sánh giá trị phần tử trình

ế

(81)

• Xét dãy số :

2.3.7 Sắp xếp –Heap sort

Xét dãy số :

(82)

• Phần tử mức i phần tử lớn cặp phần

2.3.7 Sắp xếp –Heap sort

Phần tử mức i phần tử lớn cặp phần tử tương ứng mức i+1

⇒ pphần tử mức (nút g( gốc cây) phy) p ần tử

lớn dãy

• Nếu loạại bỏ php ần tử ggốc khỏi (nghy ( g ĩa đưa phần tử lớn vị trí), việc cập nhật xảy nhánh liên quan đến phần tử

mới loại bỏ, cịn nhánh khác bảo tồn, nghĩa bước sử dụng lại kết so sánh

ở bước

(83)

• Loại bỏ khỏi vào chỗ trống

2.3.7 Sắp xếp –Heap sort

(84)

T há h t ủ â ũ đ bả t

2.3.7 Sắp xếp –Heap sort

• Tồn nhánh trái cũ bảo toàn

(85)

• Tiến hành nhiều lần việc loại bỏ phần tử gốc

2.3.7 Sắp xếp –Heap sort

Tiến hành nhiều lần việc loại bỏ phần tử gốc tất phần tử -∞,

đó xếp phần tử theo thứ tự loại bỏ có dãy xếp

• Để cài đặt thuật tốn hiệu quả, cần phải tổ chức

ấ ể

cấu trúc lưu trữ liệu có khả thể quan hệ phần tử với n nhớ thay hư t í d

2n-1 ví dụ

(86)

Định nghĩa heap:

ầ

2.3.7 Sắp xếp –Heap sort

• Heap dãy phần tử aleft, aleft+1, , aright thoả quan hệ:

– ai ≥ a2i

– ai ≥ a2i+1

– với ∀i ∈ [left, right]

• Khi (ai , a2i), (ai ,a2i+1) gọi cặp phần tử liên đới

• Heap định nghĩa dùng

ờ h ắ ế ă dầ ắ ế iả dầ

(87)

Ví dụ dãy heap:

2.3.7 Sắp xếp –Heap sort

Ví dụ dãy heap:

1 2 3 4 5 6 7

0 1 2 3 4 5 6 7

0

12 8 5 1 4 6 2

(88)

a Các phần tử

2.3.7 Sắp xếp –Heap sort

a1 Các phần tử

của dãy biểu diễn theo

ố

a2 a3 mối quanhệ liên đới

a4 a5 a6 a7

(89)

ố ấ

2.3.7 Sắp xếp –Heap sort

• Một số tính chất Heap:

– Tính chất 1: Nếu aleft, aleft+1, …, aright heap

ắ ố ầ ầ

thì cắt bỏ số phần tử hai đầu heap, dãy lại heap

Tí h hấ 2 Nế ột h

– Tính chất 2: Nếu a0, a1, …, an-1 heap phần tử a0 (đầu heap) ln phần tử lớn heap

trong heap

– Tính chất 3: Mọi dãy aleft, aleft+1, , aright thỏa: 2left > right heap

(90)

Ví dụ các tính chất của heap

2.3.7 Sắp xếp –Heap sort

Ví dụ các tính chất của heap

1 2 3 4 5 6 7

0

12 8 5 1 6 4 2

15

12 8 5 1 6 4

(91)

Sắ ế dã tă dầ i i đ

2.3.7 Sắp xếp –Heap sort

• Sắp xếp dãy tăng dần qua giai đoạn:

– GiaiGiai đđooạạn 1:n 1: DDựựa vào tính cha vào tính chấất ct củủa heapa heap đểđể hihiệệuu chỉnh dãy ban đầu thành heap

– Giai đoạn 2: Dựa vào tính chất heap

để xếp heap có sau giai đoạn thành dãy

(92)

Vấ đề Đổi hỗ ột ố hầ tử t ê dã

2.3.7 Sắp xếp –Heap sort

• Vấn đề: Đổi chỗ số phần tử dãy a1,…, an để dãy trở thành heap

• Ý tưởng: theo tính chất 3, dãy an/2+1, an/2+2, ,an đương nhiên heap Lần lượt thêm vào phía trước dãy phần tử an/2, an/2-1, …, a1; bước thêm vào cần hiệu chỉnh vị trí phần tử theo mối quan hệ liên đới ta nhận

(93)

2 Sắp xếp Heap sort 2.3.7 Sắp xếp –Heap sort

Giai đoạn 1

//input: dãy (a, n)

//output: dãy (a n) heap

//output: dãy (a, n) heap

• Bước 1: left = n/2; //Thêm phần tử aleft, , a1 vào heap

heap

• Bước 2: Trong left >

//Lưu ý: đoạn a a heap //Lưu ý: đoạn aleft+1, …, an heap

– Bước 21: Hiệu chỉnh đoạn aleft, …, an thành heap

(94)

Giai đoạn 1 Giai đoạn 1

1 2 3 4 5 6 7

0

2 8 5 1 6 4 15

(95)

15

1 2 3 4 5 6 7

0 curr joint joint

5 15

2 8 5 1 6 4

12

l ft

5

(96)

1 2 3 4 5 6 7

0 curr joint joint joint

2 8 15 1 6 4 5

12

l ft

8

(97)

1 2 3 4 5 6 7

0 joint joint curr

15 8 5 1 6 4 2

12

(98)

1 2 3 4 5 6 7

0

12 8 5 1 6 4 2

(99)

• Vấn đề: Sắp xếp heap a0, …, an-1 thành dãy tăng dần

//Đặt: right = n-1 Ỵ dãy a1, …, aright là heap. //Đặt: right n 1 Î dãy a1, …, aright là heap.

• Ý tưởng:

– Theo tính chất 2: a sẽTheo tính chất 2: a0 phần tửlà phần tử lớn vịlớn nhất, vị trítrí đúngđúng a0 phải right - cuối dãy

→ Đổi chỗ (a0, arightg ) Ỵ thêm phần tử vị trí

– Theo tính chất 3: dãy a1, …, aright-1 heap Giả i ht thê dã hiệ hỉ h l i

(100)

//input: dãy (a, n) heap

//output: dãy (a, n) tăng dần

B i h //Bắ đầ h hiệ ối dã

• Bước 1: right = n-1; //Bắt đầu thực từ cuối dãy

• Bước 2: Trong right >

//Đ hầ tử lớ hất ( ) ề ị t í i ht //Đưa phần tử lớn (a0)về vị trí right

– Bước 21: Hoánvị (a0 , aright);

//Loại bỏ phần tử lớn khỏi heap //Loại bỏ phần tử lớn khỏi heap – Bước 22: right := right -1;

– Bước 23: Hiệu chỉnh đoạn a0, a1, …, arightg thành heap

(101)

Giai đoạạn 2

12 8 5 1 6 4 2

15

1 2 3 4 5 6 7

0

right

(102)

joint joint

curr

12 8 5 1 6 4 15

2

1 2 3 4 5 6 7

0 joint joint curr

right

(103)

5 8 2 1 6 4 15

12

1 2 3 4 5 6 7

0

right

(104)

joint joint

curr joint

5 8 2 1 6 12 15

4

1 2 3 4 5 6 7

0 joint joint

curr joint

right

(105)

5 6 2 1 4 12 15

8

1 2 3 4 5 6 7

0

right

(106)

5 6 2 1 8 12 15

4

1 2 3 4 5 6 7

0

2 4 6 8 12 1

1 2 4 5 6 8 12 15

(107)

Hiệu chỉnh Heap

• Vấn đề: dãy aleft+1, aleft+2, …, aright heap, cần hiệệu chu c ỉnh lạạ đểi để aaleftleft, …, a, …, arightright heapà eap

• Ý tưởng: aleft+1, aleft+2, …, aright heap nên tất

các phần tử thỏa điều kiện liên đới Ỵ

vấn đề trở thành: kiểm tra quan hệ liên đới aleft đổi chỗ aleftleft với liên đới thích hợợp cp quan hệ liên đới bị vi phạm; sau hiệu chỉnh vi phạm điều kiện liên đới lan truyền đến vị

(108)

1 2 3 4 5 6 7

0 curr joint joint joint

2

2 8 15 1 6 4 5

(109)

Nhận xét: Q trình hiệu chỉnh có nhiều bước

đổi chỗ trung gian không cần thiết

đổi chỗ trung gian khơng cần thiết

• Trong ví dụ: đổi chỗ (2, 15), sau đổi chỗ

tiế (2 5) ị t í ối ù ủ ị t í tiếp (2, 5): vị trí cuối 8, vị trí tạm thời, khơng cần thiết

ể ỗ

• Có thể thực việc dời chỗ hàng loạt, sau

(110)

// dã là h

2.3.7 Sắp xếp –Heap sort

//input: dãy aleft+1, aleft+2, …, aright là heap //output: dãy aleft, aleft+1, …, aright là heap

• Bước 1:

– curr = left; x = acurr; //Bắt đầu kiểm tra từ vị trí left

– joint = 2*curr + 1; //Liên đới thứ nhất curr

• Bước 2: Trong (jointg (j ≤ right)g ) //Còn liên đới để xét

– Bước 21: Nếu (joint < right) && (ajoint+1 > ajoint)

joint = joint + 1; //joint: vị trí liên đới lớn nhất

– BBướước 22: Nc 22: Nếếu au ajointjoint ≤≤ xx //Th//Thỏỏaa đđiiềều kiu kiệện liênn liên đớđớii

Chuyển đến Bước

– Bước 23: acurr = ajoint; curr = joint; joint = 2*curr + 1;

(111)

Hiệu chỉnh Heap Hiệu chỉnh Heap

2

2 8 15 1 6 4 5

1 2 3 4 5 6 7

0 curr joint ??? joint

2

2 8 15 1 6 4 5

l ft right

(112)

Cài đặt

• Để cài đặt giải thuật Heapsort cần xây dựng thủ

tục:

– Thủ tục hiệu chỉnh dãy aleft, aleft+1, …, aright thành heap:

void Shift(int a[],int left,int right)

h h ể đổi d h h h

– Thủ tục chuyển đổi dãy a0, a2, …, an-1 thành heap:

void CreateHeap(int a[], int n )

Thủ tục xếp dãy a a a tăng dần:

– Thủ tục xếp dãy a0, a2, …, an-1 tăng dần:

(113)

void Shift (int a[], int left, int right) {

2.3.7 Sắp xếp –Heap sort

Cài đặt

{

int x, curr, joint;

curr = left; joint =2*curr+1 ; // ajoint: phần tử liên đới x = a[curr];

x = a[curr];

while (joint <= right) {

if (joint < right) // có đủ 2 phần tử liên đới

if (joint < right) // có đủ phần tử liên đới

if (a[joint] < a[joint+1]) joint = joint+1;

if (a[joint]<x) j break; //thoả quan hệ liên đớiq a[curr] = a[joint];

curr = joint; // xét tiếp khả hiệu chỉnh lan truyền joint = 2*curr+1;

(114)

Cài đặt

void CreateHeap(int a[], int n) {

int left;

//left: vị trí phần tử cần ghép thêm

for (left = (n-1)/2; left >= 0; left )

(115)

Cài đặt

void HeapSort (int a[], int n) {

intt right;g t;

CreateHeap(a, n); //sắp xếp dãy a thành heap

right = n-1; // right vị trí cho phần tử lớn nhất

hil ( i ht > 0)

while (right > 0) {

swap(a[0],a[right]); right ;

Shift(a,0,right); }

(116)

Đánh giá

• Việc đánh giá cách xác giải thuật Heapsort phức tạp Tuy nhiên, đánh giá cách tương đối dựa vào số nhận xét:

một cách tương đối dựa vào số nhận xét:

– Khi xem xét heap dạng quan hệ liên đới Ỉ phần tử heap tạo thành nhịp y ị phân cóp độộ cao h≈logg22n

– Ở bước hiệu chỉnh, số phép điều chỉnh vi phạm liên đới không vượt chiều cao h liên đới

Ở ố

– Ở giai đoạn giai đoạn số phép hiệu chỉnh không vượt n

ỴTrong trường hợp xấu độ phức tạp thuật tốn

(117)

2 Sắp xếp chèn với độ dài bước giảm 2.3.8 Sắp xếp chèn với độ dài bước giảm

dần - Shell sort

Ý t ở

• ShellSort phương pháp cải tiến phương pháp xếp chèn trực tiếp Ý tưởng phương pháp xếp Ý tưởng

p ự p g p g p p p p y

xem xét dãy ban đầu dãy gồm phần tử cách k vị trí; tiến hành xếp dãy con; giảm dần bước k đến k = Ỵ xếp xong

dần bước k đến k = ẻ sp xp xong

ã Dóy ban u : a0, a1, , an-1 xem xen kẽ dãy sau :

– Dãy thứ : a0 ak a2k

– Dãy thứ hai : a1 ak+1 a2k+1

(118)

Ý tưởng

• Việc xếp phần tử dãy làm cho phần tử đưa vị trí tương đối (chỉ dãy so với toàn phần tử dãy ban đầu chưa Ý tưởng

con, so với toàn phần tử dãy ban đầu chưa đúng) cách nhanh chóng

• Khi khoảng cách k giảm tạo thành dãy mớig g y Ỵ phần tử so sánh với nhiều phần tử khác trước khơng dãy với

• Thuật tốn dừng sau xong dãy với k thuật tốn

• Thuật tốn dừng sau xong dãy với k = 1, thuật toán lúc thực thuật toán chèn trực tiếp Tuy nhiên, phần lớn phần tử dãy có thứ tự phận

(119)

Thuật toán

//input: dãy (a, n); dãy (h, k): k độ dài bước lặp - const //output: dãy (a, n) là được tăng dần

Thuật toán

//output: dãy (a, n) tăng dần

• Bước 1: step = 1; //h[step]: độ dài bước lặp

• Bước 2Bước 2: Trong (step: Trong (step ≤≤ k) k) //độ//độ dài bước >1dài bước >1 – Bước 21: len = h[step]; //lấy độ dài bước

– Bước 22: Lặặp vp ới i=len+1 n-1 //sắp xp ếp dãy liên p y

đới bước len Chèn a[i] vào dãy liên đới bước len;

(120)

Ví dụ

h = (5, 3, 1); k = 3; len = 5;

Ví dụ

1 2 3 4 5 6 7

0

( , , ); ; ;

curr

joint

2 8 5 1 6 4 15

12

1 2 3 4 5 6 7

(121)

Ví dụ

h = (5, 3, 1); k = 3;

Ví dụ

len = 5;

1 2 3 4 5 6 7

0

( , , ); ; ;

2 8 5 1 12 4 15

6

1 2 3 4 5 6 7

(122)

Ví dụ

h = (5, 3, 1); k = 3;

Ví dụ

len = 3;

1 2 3 4 5 6 7

0

( , , ); ;

curr

joint

;

2 15 5 1 12 4 8

6

1 2 3 4 5 6 7

(123)

Ví dụ

h = (5, 3, 1); k = 3; len = 3;

1 2 3 4 5 6 7

0 curr

joint joint

( , , ); ; ;

1 12 6 2 15 4 8

5

1 2 3 4 5 6 7

(124)

Ví dụ

h = (5, 3, 1); k = 3; len = 3;

1 2 3 4 5 6 7

0

( , , ); ; ;

1 12 5 2 15 6 8

4

1 2 3 4 5 6 7

(125)

Ví dụ

h = (5, 3, 1); k = 3; len = 1;

jointcurr

1 2 3 4 5 6 7

0

joint joint

( , , ); ; ;

1 12 5 2 15 6 8

4

1 2 3 4 5 6 7

(126)

Ví dụ

h = (5, 3, 1); k = 3; len = 1;

jointcurr

joint

1 2 3 4 5 6 7

0

joint joint jointjoint joint joint

( , , ); ; ;

4 5 12 2 15 6 8

1

1 2 3 4 5 6 7

(127)

Ví dụ

1 2 3 4 5 6 7

0

2 4 5 6 8 12 15

1

1 2 3 4 5 6 7

(128)

Cài đặt

void ShellSort(int a[], int n) {

int h[], k;

Cài đặt

int step, i, pos, x, len;

for (step = 0; step < k; step ++) {

ầ ế

len = h[step]; //khoảng cách phần tử liên tiếp dãy con

for (i = len; i < n; i++) {

[i] x = a[i];

for(pos=i;(pos-len>=0)&&(x<a[pos-len]);pos-=len) a[pos] = a[pos-len];

(129)

Đá h iá

• Yếu tố định tính hiệu thuật tốn: Đánh giá

– Cách chọn khoảng cách h bước xếp

– Số bước xếp

• Giả sử định xếp k bước, khoảng cách chọn phải thỏa điều kiện :

(130)

Đá h iá

• Chưa có tiêu chuẩn rõ ràng việc lựa chọn dãy iá t ị kh ả h tốt hất Một ợi ý dã đượ Đánh giá

giá trị khoảng cách tốt Một gợi ý: dãy chọn khơng nên có số bội số

• Một số dãy Knuth đề nghị :

hi = (hi-1 - 1)/3 hk = 1, k = log3n-1

í d 121 40 13 ví dụ: 121, 40, 13, 4, hay

h (h 1)/2 h k l

(131)

Đá h iá

• Việc đánh giá giải thuật Shellsort dẫn đến vấn

đề t h ất t thậ hí ột ố h đ Đánh giá

đề tốn học phức tạp, chí số chưa chứng minh

Hiệ ả ủ th ật t ò h th ộ dã độ

• Hiệu thuật tốn cịn phụ thuộc vào dãy độ

dài chọn

• Trong trường hợp chọn dãy độ dài theo cơng thức

• Trong trường hợp chọn dãy độ dài theo công thức

hi = (hi-1 - 1)/2 hk = 1, k = log2n-1

thì iải th ật ó độ t <<

(132)

2 Sắp xếp dựa phân hoạch Quick 2.3.9 Sắp xếp dựa phân hoạch – Quick

sort

Ý tưởng

• Một vài hạn chế thuật toán Đổi chỗ trực tiếp:

– Mỗi lần đổi chỗ thay đổi cặp phần tử nghịch thế;

Ý tưởng

Mỗi lần đổi chỗ thay đổi cặp phần tử nghịch thế; trường hợp như: i < j < k ai > aj > ak (*) chỉ cần thực hiện lần

đổi chỗ (ai, ak): thuật tốn khơng làm

Độ t ủ th ật t O( 2) Ỵ khi đủ lớ th ật t á ẽ

– Độ phức tạp thuật tốn O(n2) Ỵ khi n đủ lớn thuật tốn sẽ

rất chậm

Ỵ Ý tưởng: phân chia dãy thành cácg p y đoạạn Ỉ tậận dụụngg

được phép đổi chỗ dạng (*) làm giảm độ dài dãy xếp Ỉ cải thiện đáng kể độ phức tạp thuật t

(133)

sort

Ý tưởng

• Giải thuật QuickSort xếp dãy a0, a1 , an-1 dựa việc phân hoạch dãy ban đầu thành phần:

Ý tưởng

phân hoạch dãy ban đầu thành phần:

– Phần 1: Gồm phần tử có giá trị khơng lớn x

– Phần 2: Gồm phần tử có giá trị x

Phầ Gồ hầ ó iá ị khô bé h

– Phần 3: Gồm phần tử có giá trị khơng bé x

với x giá trị phần tử tùy ý dãy ban đầu

• Sau thực phân hoạch dãy banSau thực phân hoạch, dãy ban đầuđầu phân thành 3được phân thành đoạn:

1 ak ≤ x , với k = j

2 ới k j i

(134)

sort

Ý tưởng

• Đoạn thứ có thứ tự Ý tưởng

• Nếu đoạn có phần tử chúng có thứ tự, dãy ban đầu

• Ngược lại, đoạn có nhiều phần tử

thì dãy ban đầu có thứ tự đoạn 1,

sắp

(135)

sort

Thuật toán

//input: dãy (a, left, right)

//output: dãy (a left right) được tăng dần

Thuật toán

//output: dãy (a, left, right) được tăng dần

• Bước 1: Nếu left ≥ right //dãy có phần tử Kết thúc; //dãy đã được xếp

Kết thúc; //dãy đã được xếp

• Bước 2: Phân hoạch dãy aleft … aright thành đoạn: aleft aj, aj+1 ai 1, ai aright

aj, aj+1 ai-1, ai aright

//Đoạn 0 ≤ x - Đoạn 2: aj+1 ai-1 = x - Đoạn 3: ai aright ≥ x

(136)

sort

Phân hoạch dãy //input: dãy aleft, …, aright

//output: dãy chia thành 3 đoạn: đoạn 1 ≤ đoạn 2 ≤ đoạn 3

ầ ố

Phân hoạch dãy

• Bước 1: Chọn tùy ý phần tử a[p] dãy giá trị mốc: x=a[p];

• Bước 2: Duyệt từ đầu dãy để phát hiệu chỉnh cặp phần tử a[i], a[j]

vi phạmp điều kiệnệ

– Bước 21: i = left; j = right;

– Bước 22: Trong (a[i]<x) i++;

Bước 23: Trong (a[j]>x) j ;

– Bước 23: Trong (a[j]>x) j ;

– Bước 24: Nếu i<= j // a[i] ≥ x ≥ a[j] mà a[j] đứng sau a[i]

• Hoán vị (a[i],a[j]); i++; j ;

ế ế

(137)

2 Sắp xếp dựa phân hoạch Quick

2.3.9 Sắp xếp dựa phân hoạch – Quick sort

Ví dụ

5

X

Ví dụ

1 2 3 4 5 6 7

0i j

2 8 5 1 6 4 15

12

left right

(138)

sort

Ví dụ Phân hoạch dãy

5

X

1 2 3 4 5 6 7

0 i j

2 8 5 1 6 12 15

4

left right

(139)

sort

Ví dụ

1 2 3 4 5 6 7

0 j i

2 1 5 8 6 12 15

4

(140)

sort

6

X

1 2 3 4 5 6 7

0 i j

2 4 5 8 6 12 15

1

left right

STOP STOP

Sắp xếp đoạn 3 STOP STOP

(141)

sort

Ví dụ

1 2 3 4 5 6 7

0 j i

2 4 5 6 8 12 15

1

left right

(142)

sort

Ví dụ

1 2 3 4 5 6 7

0

2 4 5 6 8 12 15

(143)

sort

Cài đặt

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

{

int i, j, x;

Cài đặt

if (left >= right) return;

x = a[(left+right)/2]; // chọn phần tử làm giá trị mốc i = left; j = right;

while(i < j) {( j) {

while(a[i] < x) i++;

while(a[j] > x) j ;

if(i <= j) {

( [i] [j])

swap(a[i], a[j]); i++ ; j ;

} }

(144)

sort

Nhận xét

• Về ngun tắc, chọn giá trị mốc x phần tử tùy ý dãy, để đơn giản, phần tử có vị trí thường Nhận xét

được chọn, p = (l + r) /

• Giá trị mốc x chọn có tác động đến hiệu thực thuật tốn định số lần phân hoạch

thuật tốn định số lần phân hoạch

– Số lần phân hoạch ta chọn x phần tử trung vị (median), nhiều x cực trị dãy

(145)

sort

Đánh giá

• Hiệu phụ thuộc vào việc chọn giá trị mốc:

– Trường hợp tốt nhất: lần phân hoạch chọn

Đánh giá

Trường hợp tốt nhất: lần phân hoạch chọn phần tử median làm mốc, dãy phân chia thành phần cần log2(n) lần phân hoạch

ắ ế

thì xếp xong

– Nếu lần phân hoạch chọn phần tử có giá trị cực

đ i (h tiể ) ố Ỵ dã ẽ bị hâ hi h

(146)

sort

Độ hứ t th ật t á

Độ phức tạp thuật toán

Trường hợp Độ phức tạp

Tốt nhất O(nlogn)

Trung bình O(nlogn)

Xấu nhất O(n2)

(147)

2.3.10 Sắp xếp theo phương pháp trộn trực 2.3.10 Sắp xếp theo phương pháp trộn trực

tiếp – Merge sort

Ý tưởng

• Giải thuật Merge sort xếp dãy a0, a1, , an-1 dựa trên nhận xét sau:

Ý tưởng

nhận xét sau:

• Mỗi dãy a0, a1, , an-1 bất kỳ là tập hợp dãy con liên tiếp mà mp ỗi dãy cony đều đã có thứ tựự.

– Ví dụ: dãy 12, 2, 8, 5, 1, 6, 4, 15 coi gồm dãy không giảm (12); (2, 8); (5); (1, 6); (4, 15)

• Dãy có thứ tự coi có dãy

• Hướng tiếp cận: tìm cách làm giảm số dãy khơng

ầ

(148)

Ý tưởng

• Các vấn đề cần giải quyết:

– Phương án phân hoạch dãy ban đầu thành dãy

– Phương án làm giảm số dãy

Ý tưởng

Phương án làm giảm số dãy

• Phân hoạch dãy ban đầu thành dãy tăng dần:

– Phương án 1: Phân hoạch dãy theo đường chạy Ỉ xếp trộn tự

nhiên

– Phương án 2: Phân hoạch thành dãy có số phần tử (1, 2, 4, …) Æ xếp trộn trực tiếp

• Làm giảm số dãy con:

– Các dãy tăng dần tách dãy phụ theo nguyên tắc phân phối đều luân phiên.

(149)

Thuật toán

//input: dãy (a, n)

//output: dãy (a, n) được tăng dần

ầ Thuật toán

• Bước : k = 1; // dãy có phần tử là dãy khơng giảm

• Bước : Lặp (k < n) // dãy dãy con

h hối đề l hi d h h d b

– Bước 21: Phân phối luân phiên dãy a0, a1, …, an-1 thành dãy b, c theo nhóm k phần tử liên tiếp

//b = a00, …, ak-1k 1, a2k2k, …, a3k-13k 1, … //c = ak, …, a2k-1, a3k, …, a4k-1, …

– Bước 22: Trộn cặp dãy gồm k phần tử dãy b, c vào a B 23 k k*2

(150)

Ví dụ

k = 1; Phân phối luân phiên Ví dụ

1 2 3 4 5 6 7

0

;

2 8 5 1 6 4 15

(151)

Ví dụ

1 2 3 4 5 6 7

0

;

2 8 5 1 6 4 15

(152)

Ví dụ

k = 1; Trộn cặp đường chạy Ví dụ

1 2 3 4 5 6 7

0

;

8 1 4

12

(153)

Ví dụ

1 2 3 4 5 6 7

0

8 1 4

12

(154)

Ví dụ

1 2 3 4 5 6 7

0

;

12 5 8 1 6 4 15

(155)

Ví dụ

1 2 3 4 5 6 7

0

12 1 6

2

(156)

Ví dụ

1 2 3 4 5 6 7

0

12 1 6

2

(157)

Ví dụ

1 2 3 4 5 6 7

0

;

5 8 12 1 4 6 15

(158)

Ví dụ

1 2 3 4 5 6 7

0

5 8 12

2

(159)

Ví dụ

1 2 3 4 5 6 7

0

;

5 8 12

2

(160)

Ví dụ

k = 8;

Ví dụ

1 2 3 4 5 6 7

0

2 4 5 6 8 12 15

1

STOP

(161)

Ví dụ

1 2 3 4 5 6 7

0

2 4 5 6 8 12 15

(162)

Cài đặt

• Dữ liệu hỗ trợ: mảng b, c:

int b[MAX], c[MAX], nb, nc;

ầ

Cài đặt

• Các hàm cần cài đặt:

– MergeSort: Sắp xếp mảng (a, n) tăng dần

void MergeSort(int a[], int n);

ố ề

– Distribute: Phân phối luân phiên dãy độ dài k từ mảng

a vào hai mảng b c

void Distribute(int a[], int n,

int &nb int &nc int k);

int &nb, int &nc, int k);

– Merge: Trộn mảng b mảng c vào mảng a

void Merge(int a[], int nb, int nc, int k);

(163)

Cài đặt

// khai báo mảng phụ

int b[MAX], c[MAX], nb, nc;

Cài đặt

[ ], [ ], , ;

void MergeSort(int a[], int n) {

{

int k;

for (k = 1; k < n; k *= 2) {

{

Distribute(a, n, nb, nc, k);

Merge(a, nb, nc, k);

(164)

Cài đặt

void Distribute(int a[], int n,

int &nb, int &nc, int k) {

Cài đặt

{

int i, pa, pb, pc; pa = pb = pc = 0;

while (pa < n)(p ) {

for (i=0; (pa<n) && (i<k); i++, pa++, pb++) b[pb] = a[pa];

b[pb] a[pa];

for (i=0; (pa<n) && (i<k); i++, pa++, pc++) c[pc] = a[pa];

(165)

Cài đặt

void Merge(int a[], int nb, int nc, int k) {

Cài đặt

int pa, pb, pc; pa = pb = pc = 0;

while ((pb < nb) && (pc < nc))

while ((pb < nb) && (pc < nc))

MergeSubarr(a, nb, nc, pa, pb, pc, k);

while (pb < nb)

a[pa ++] = b[pb ++];

while (pc < nc)

(166)

Cài đặt

void MergeSubarr(int a[], int nb, int nc,

int &pa, int &pb, int &pc, int k) {

Cài đặt

{

int rb, rc;

rb = min(nb, pb+k); rc = min(nc, pb+k);

while ((pb < rb) && (pc < rc))

if (b[pb] < c[pc])

a[pa ++] = b[pb ++];

else a[pa ++] = c[pc ++];

while (pb < rb)

a[pa ++] = b[pb ++];

while (pc < rc)

(167)

Đánh giá

Giải thuật trộn trực tiếp phương pháp trộn đơn giản nhất:

• Việc phân hoạch thành dãy tách dãy thành

Đánh giá

dãy khơng giảm độ dài k

• Độ dài dãy 1, 2, 4, 8, … đảm bảo dãy dãy không giảm sau bước tách trộn

dãy không giảm sau bước tách - trộn

• Khơng sử dụng thông tin thứ tự dãy ban đầu

→ hệệ quả:q

• Độ phức tạp thuật tốn khơng phụ thuộc vào dãy ban đầu

• Một dãy khơng giảm có sẵn bị chia nhỏ thành

ầ ế ế

(168)

Đánh giá

• Số lần thực việc chia luân phiên trộn:

ỗ ầ

Đánh giá

• Sau lần tách – trộn, độ dài K dãy tăng gấp đôi Æ Số lần tách – trộn thuật toán: log2n

• Chi phí thực tách - trộn tỉ lệ thuận với n

(169)

Đánh giá

• Một nhược điểm lớn thuật tốn trộn cài đặt thuật tốn địi hỏi thêm Đánh giá

trộn cài đặt thuật tốn địi hỏi thêm khơng gian nhớ để lưu dãy phụ b, c

• Hạn chế khó chấp nhận thực tế

• Hạn chế khó chấp nhận thực tế dãy cần xếp thường có kích thước lớn

Vì ậ th ật t t ộ th đ dù để

• Vì thuật tốn trộn thường dùng để

sắp xếp cấu trúc liệu khác phù hợp h d h h liê kết h ặ fil

(170)

Sắp xếp trộn tự nhiên – Natural Merge Sort

• Một đường chạy dãy số a dãy không giảm cực đại a Nghĩa là, đường chạy r = (ai, ai+1, …, aj) phải

ề

Sắp xếp trộn tự nhiên Natural Merge Sort

j

thỏa điều kiện:

⎪

⎧ak ≤ ak+1 ∀k ∈[i, j)

⎪ ⎩ ⎪ ⎨ > < − 1 i i a a a a

• Ví dụ dãy 12, 2, 8, 5, 1, 6, 4, 15 coi gồm đường

⎩ >a j aj+1

ụ y , , , , , , , g g

(171)

• Thuật tốn trộn tự nhiên khác thuật tốn trộn

iế hỗ h ì l ô ứ hắ hâ

trực tiếp chỗ thay ln cứng nhắc phân hoạch theo dãy có chiều dài k, việc phân

h h h đ ị đ h hỉ ầ

hoạch theo đơn vị đường chạy ta cần biết số đường chạy a sau lần phân hoạch

ối ù ó hể biế hời điể dừ ủ

cuối biết thời điểm dừng thuật tốn dãy có thứ tự dãy có

đ h

(172)

• Bước : // Chuẩn bị

r = 0; // r dùng để đếm số dường chạy

; g g ạy

• Bước : Tách dãy a1, a2, …, an thành dãy b, c theo nguyên tắc luân phiên đường chạy:

– Bước 2.1 :

• Phân phối cho b đường chạy; r = r+1;

• Nếu a cịn phần tử chưa phân phối

– Phân phối cho c đường chạy; r = r+1;

– Bước 2.2 : Nếu a phần tử: quay lại bước 2.1;

• Bước : Trộn cặp đường chạy dãy b c vào a

(173)

2.3.11 Sắp xếp theo phương pháp cơ số – 2.3.11 Sắp xếp theo phương pháp cơ số

Radix sort

Ý tưởng

• Radix Sort thuật tốn tiếp cận theo hướng hồn tồn khác

Ý tưởng

• Nếu thuật tốn khác, sở để xếp việc so sánh giá trị phần tử Radix

l i d ắ h l i h b

Sort lại dựa nguyên tắc phân loại thư bưu

điện Vì lý Radix Sort cịn có tên Postman’s sort

sort

• Radix Sort không quan tâm đến việc so sánh giá trị

của phần tử mà thân việc phân loại trình tự

(174)

Radix sort

Ý tưởng

• Để chuyển khối lượng thư lớn đến tay người nhận nhiều địa phương khác nhau, bưu điện thường tổ chức hệ thống

ấ Ý tưởng

phân loại thư phân cấp

• Trước tiên, thư đến tỉnh, thành phố chung vào lô để gửi đến tỉnh thành tương ứng

chung vào lô để gửi đến tỉnh thành tương ứng

• Bưu điện tỉnh thành lại thực công việc tương tự Các thư đến quận, huyện xếp vào chung lô gửi đến quận, huyện tương ứng

(175)

Radix sort

Ý tưởng

• Mơ lại qui trình trên, để xếp dãy a0, a1, , iải th ật R di S t thự hiệ hư

Ý tưởng

an-1, giải thuật Radix Sort thực sau:

– Trước tiên, ta giả sử phần tử ai dãy a0, a1 a 1 số nguyên có tối đa m chữ số

a1, , an-1 số nguyên có tối đa m chữ số

– Ta phân loại phần tử theo chữ số hàng

(176)

Radix sort

Thuật tốn

• Bước :// k cho biết chữ số dùng để phân loại hành k = 0; // k = 0: hàng đơn vị; k = 1: hàng chục; … Thuật toán

; g ị; g ụ ;

• Bước : //Tạo lô chứa loại phần tử khác Khởi tạo 10 lô B0, B1, …, B9 rỗng;

• Bước : For i = n-1

Đặt ai vào lô Bt với t: chữ số thứ k ai;

B Nối B B B l i (th đú t ì h t ) h

• Bước : Nối B0, B1, …, B9 lại (theo trình tự) thành a

• Bước : k = k+1;

(177)

Radix sort

Ví dụ

(178)

Radix sort

Ví dụ

(179)

Radix sort

Ví dụ

(180)

Radix sort

Ví dụ

(181)

Radix sort

Ví dụ

(182)

Radix sort

Đánh giá

• Với dãy n số, số có tối đa m chữ số, thuật toán thực m lần thao tác phân lô Đánh giá

thuật tốn thực m lần thao tác phân lơ ghép lô

T th tá hâ lô ỗi hầ tử hỉ đ

• Trong thao tác phân lô, phần tử xét lần, ghép

(183)

Radix sort

Nhận xét

• Sau lần phân phối thứ k phần tử A vào lô B0, B1, …, B9, lấy ngược trở ra, xét đến Nhận xét

0 y g

k+1 chữ số phần tử A, ta có mảng tăng dần nhờ trình tự lấy từ → Nhận xét

à bả đả í h đú đắ ủ h ậ bảo đảm tính đắn thuật tốn

• Thuật tốn có độ phức tạp tuyến tính nên hiệu

ắ dã ố ất hiề hầ tử hất khó ắ ế

sắp dãy cố nhiều phần tử, khóa xếp khơng q dài so với số lượng phần tử (điều thường gặp thực tế)

(184)

Radix sort

Nhận xét

• Thuật tốn khơng có trường hợp xấu tốt Mọi dãy số với chi phí

Nhận xét

tốt Mọi dãy số với chi phí chúng có số phần tử khóa có chiều dài

khóa có chiều dài

• Thuật tốn cài đặt thuận tiện với mảng với khóa xếp chuỗi (ký tự hay số) khóa xếp chuỗi (ký tự hay số) khóa số ví dụ tránh chi phí lấy chữ số số

(185)

Radix sort

Nhận xét

• Số lượng lơ lớn (10 dùng số thập phân, 26

khi dù h ỗi ký t tiế A h ) h

Nhận xét

khi dùng chuỗi ký tự tiếng Anh, …) tổng kích thước tất lơ dãy

b đầ ê t khô thể dù ả để biể

ban đầu nên ta dùng mảng để biểu diễn B Như vậy, phải dùng cấu trúc liệu

độ để biể diễ B ⇒ R di S t ất thí h

(186)

Radix sort

Nhận xét

• Người ta dùng phương pháp phân lô theo

ể ễ ắ ế

Nhận xét

biểu diễn nhị phân khóa xếp Khi ta dùng hồn tồn cấu trúc liệu mảng

ể ể ễ ầ

để biểu diễn B cần dùng hai lơ B0 B1 Tuy nhiên, chiều dài khóa lớn Khi

ắ ề ầ

Định dạng
Số trang	186
Dung lượng	2,4 MB