Chuong 4 - Cac Giai Thuat Sap Xep Trong

CẤU TRÚC DỮ LIỆU & GIẢI THUẬT (CN)
CÁC GIẢI THUẬT

SẮP XẾP TRONG
GIẢNG VIÊN: TS. TRƯƠNG QUỐC BẢO

NỘI DUNG CỦA
2
CHƯƠNG
 Giới thiệu bài toán sắp xếp

 Phân loại bài toán sắp xếp
 Các kỹ thuật sắp xếp trong
 Đơn giản
 Nâng cao
Saturday, July 22, 2017 Cấu Trúc Dữ Liệu & Giải Thuật CN 2
BÀI TOÁN SẮP XẾP
 Bài toán vận dụng  Danh sách các đối

thường xuyên trong tin tượng cần sắp xếp sẽ
học và điều khiển. là một mảng của các
mẩu tin được sắp thứ
 Sắp xếp là yêu cầu không
tự dựa trên giá trị của
thể thiếu khi thiết kế các
trường khóa (key).
phần mềm.
Kiểu của Key là một
 Sắp xếp trong - Dữ liệu kiểu có quan hệ thứ tự.
được tổ chức trong bộ
 Mục đích của việc sắp
nhớ trong của máy.
xếp là tổ chức lại các
 Sắp xếp ngoài - Sử mẩu tin sao cho các
dụng khi số lượng đối khóa của chúng được
tượng cần sắp xếp rất lớn sắp thứ tự tương ứng
nên dữ liệu phải lưu trữ với quy luật sắp xếp.
trên bộ nhớ ngoài.
Saturday, July 22, 2017 3
Cấu Trúc Dữ Liệu & Giải Thuật CN
Khởi đầu
0 1 2 3 … n-1
Sau khi sắp xếp
0 1 2 3 … n-1
Cấu Trúc Dữ Liệu & Giải Thuật
CN
THỦ TỤC HOÁN ĐỔI 2 MẪU TIN
KHÔNG ĐÚNG THỨ TỰ
void swap(int i, int j){  Thủ tục đổi chỗ

Swap lấy 1 đơn vị
int temp = a[i];
thời gian để thực
a[i]=a[j]; hiện thao tác vì chỉ
thực hiện 3 lệnh
a[j]=temp; gán nối tiếp nhau.
}

CÁC KỸ THUẬT SẮP XẾP TRONG
 Đơn giản  Nâng cao

 Đổi chỗ  Heap sort
 Sắp xếp chọn  Quicksort
 Sắp xếp xen  Bin sort
 Sắp xếp nổi bọt.  Merge sort
 …..

Kỹ Thuật phân tích giải thuật
SẮP XẾP ĐỔI CHỖ
 Xét hai phần tử liên tiếp i và j nếu

không đúng thứ tự thì đổi chỗ 2 phần
j tử này
1, 4, 3, 0, 8, 6, 7, 3, 0, 2
i
int a[]={1,4,3,0,8,6,7,3,0,2};
void sort( int n) {
for (int i=0; i<n-2; i++)
Complexity: O(n2)
for (int j=i+1; j<n-1; j++)
if (a[i]>a[j])
swap(i,j);
};

SẮP XẾP CHỌN (SELECTION SORT)
 Các phần từ 0 tới a[i-1] đã có thứ tự.
 Các phần tử từ i trở đi chưa có thứ tự.
Chưa sắp  Tại bước thứ i

 Tìm phần tử
nhỏ nhất từ i
 Đổi chỗ i và j.
Đã sắp
 Sau (n-1) bước
<- swap -> dãy sẽ được
0 1 2 3 … i j n-1
sắp xếp.

SẮP XẾP CHỌN (SELECTION SORT)
Khóa
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]
Bước
Ban đầu 5 6 2 2 10 12 9 10 9 3
Bước 0 2 6 5 2 10 12 9 10 9 3
Bước 1 2 5 6 10 12 9 10 9 3
Bước 2 3 6 10 12 9 10 9 5
Bước 3 5 10 12 9 10 9 6
Bước 4 6 12 9 10 9 10
Bước 5 9 12 10 9 10
Bước 6 9 10 12 10
Bước 7 10 12 10
Bước 8 10 12
Kết quả 2 2 3 5 6 9 9 10 10 12

CHƯƠNG TRÌNH SẮP XẾP CHỌN
void selectionSort(int n){

for (int i=0 ; i<n-1 ; i++ ) {
int ind_min = i;
for (int j=i+1 ; j<n ; j++ ) Complexity: O(n2)
if ( a[j] < a[ind_min] )
ind_min = j;
swap(i,ind_min);
}
}
}

SẮP XẾP XEN (INSERTION SORT)
 Giả thiết tại bước thứ i:

 Các phần tử 0..i-1 đã sắp
 Các phần tử từ i trở đi chưa sắp thứ tự.
Chưa sắp
Đã sắp
0 1 2 3 … i-1 n-1
 Sắp phần tử thứ i:

 Xen phần tử thứ i vào đúng vị trí trong dãy
từ 0.. i
SẮP XẾP XEN (INSERTION SORT)
Khóa a[0] a[1] a[2] a[3] a[4] a[5] a[6] A[7] a[8] a[9]
Bước
Ban đầu 5 6 2 2 10 12 9 10 9 3
Bước 1 5 6
Bước 2 2 5 6
Bước 3 2 2 5 6
Bước 4 2 2 5 6 10
Bước 5 2 2 5 6 10 12
Bước 6 2 2 5 6 9 10 12
Bước 7 2 2 5 6 9 10 10 12
Bước 8 2 2 5 6 9 9 10 10 12
Bước 9 2 2 3 5 6 9 9 10 10 12

CHƯƠNG TRÌNH SẮP XẾP XEN
void insertionSort(int n){

for (int i=1 ; i<n ; i++ ){
int cont = 1, int j = i;
while ( j>0 && cont ){
if ( a[j] < a[j-1] ) Complexity: O(n2)
swap(j-1, j);
else
cont = 0;
j--; }
}
};
SẮP XẾP NỔI BỌT (BUBLE SORT)
Thứ tự Thứ tự không đúng

đúng Trước khi nổi bọt
(sắp xếp)
0 1 2 3 … n-1
Sau khi nổi bọt Thứ tự Thứ tự đúng

(sắp xếp) đúng
Khi có TT không
bình thuờng 
đổi chổ (nổi bọt) 0 1 2 3 … n-1

SẮP XẾP NỔI BỌT (BUBLE SORT)
Khóa
a[0] a[1] a[2] a[3] a[4] A[5] a[6] a[7] a[8] a[9]
Bước
Ban đầu 5 6 2 2 10 12 9 10 9 3
Bước 1 2 5 6 2 3 10 12 9 10 9
Bước 2 2 5 6 3 9 10 12 9 10
Bước 3 3 5 6 9 9 10 12 10
Bước 4 5 6 9 9 10 10 12
Bước 5 6 9 9 10 10 12
Bước 6 9 9 10 10 12
Bước 7 9 10 10 12
Bước 8 10 10 12
Bước 9 10 12
Kết quả 2 2 3 5 6 9 9 10 10 12

CHƯƠNG TRÌNH SẮP XẾP NỔI BỌT
void bubbleSort( int n) {

for (int i=0; i<n-1; i++) Complexity: O(n2)
for (int j=n-1; j>i; j--)
if (a[j]<a[j-1])
swap(j,j-1);
};

SẮP XẾP NHANH (QUICK SORT)
 Chia mảng làm 2 phần dựa trên phần tử chốt:

 Trái a[i]<v
 Phải a[i]>=v
 Sắp xếp đệ qui Trái, Phải
 Vấn đề:
 Chọn pivot - V,
 Phân phối các phần tử.
SẮP XẾP NHANH (QUICK SORT) -
PHƯƠNG PHÁP CHỌN PIVOT
 Chọn giá trị khóa lớn nhất trong hai phần
tử có khóa khác nhau đầu tiên kể từ trái qua.
 Nếu mảng chỉ gồm một phần tử hay gồm
nhiều phần tử có khóa bằng nhau thì
không có chốt.
 Ví dụ: Chọn chốt trong các mảng sau
 Cho mảng gồm các phần tử có khoá là 6, 6, 5,
8, 7, 4, ta chọn chốt là 6 (khoá của phần tử
thứ hai).
 Cho mảng gồm các phần tử có khoá là 6, 6, 7,
5, 7, 4, ta chọn chốt là 7 (khoá của phần tử
thứ 3).
PHƯƠNG PHÁP PHÂN HOẠCH
 Ðể phân hoạch mảng ta dùng 2 "con nháy" L và R
trong đó L từ bên trái và R từ bên phải.
 Ta cho L chạy sang phải cho tới khi gặp phần tử có
khóa ≥ chốt
 Cho R chạy sang trái cho tới khi gặp phần tử có
khóa < chốt.
 Tại chỗ dừng của L và R nếu L < R thì hoán vị
a[L],a[R].
 Lặp lại quá trình dịch sang phải, sang trái của 2
"con nháy" L và R cho đến khi L > R.
 Khi đó L sẽ là điểm phân hoạch, cụ thể là a[L] là
phần tử đầu tiên của mảng con “bên phải”.
L=0 R=9
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 8 2 10 5 12 8 1 15 4
Khoá
Chốt p = 8
L=1 R=9
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 8 2 10 5 12 8 1 15 4
Khoá
Chốt p = 8
L=1 R=9
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 10 5 12 8 1 15 8
Khoá
Chốt p = 8
L=2 R=9
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 10 5 12 8 1 15 8
Khoá
Chốt p = 8

L=3 R=9
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 10 5 12 8 1 15 8
Khoá
Chốt p = 8
L=3 R=8
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 10 5 12 8 1 15 8
Khoá
Chốt p = 8
L=3 R=7
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 10 5 12 8 1 15 8
Khoá
Chốt p = 8
L=3 R=7
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 1 5 12 8 10 15 8
Khoá
Chốt p = 8
L=4 R=7
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 1 5 12 8 10 15 8
Khoá
Chốt p = 8
L=5 R=7
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 1 5 12 8 10 15 8
Khoá
Chốt p = 8
L=5 R=6
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 1 5 12 8 10 15 8
Khoá
Chốt p = 8
L=5 R=5
0 1 2 3 4 5 6 7 8 9
Chỉ số
5 4 2 1 5 12 8 10 15 8
Khoá
Chốt p = 8
R=4 L=5
Chỉ 0 1 2 3 4 5 6 7 8 9
số
5 4 2 1 5 12 8 10 15 8
Khoá
Chốt p = 8
Phân hoạch
0 1 2 3 4 5 6 7 8 9
5 4 2 1 5 12 8 10 15 8
GIẢI THUẬT QUICK SORT
 Ðể sắp xếp mảng a[i]..a[j] ta làm các

bước sau:
 Xác định chốt.
 Phân hoạch mảng đã cho thành hai mảng
con a[i]..a[k-1] và a[k]..a[j].
 Sắp xếp mảng a[i]..a[k-1] (Ðệ quy).
 Sắp xếp mảng a[k]..a[j] (Ðệ quy).
 Đệ quy dừng khi không còn tìm thấy chốt.
VÍ DỤ VỀ GIẢI THUẬT QUICK SORT
Chỉ số 0 1 2 3 4 5 6 7 8 9
Khoá 5 8 2 10 5 12 8 1 15 4
Chốt p = 8
5 4 2 1 5 12 8 10 15 8
Chốt p = 5
Chỉ số 0 1 2 3 4 5 6 7 8 9
Khoá 5 8 2 10 5 12 8 1 15 4
Chốt p = 8
5 4 2 1 5 12 8 10 15 8
1 5
Chốt p = 5
1 4 2 5 5
Chốt p = 4
Chỉ số 0 1 2 3 4 5 6 7 8 9
Khoá 5 8 2 10 5 12 8 1 15 4
Chốt p = 8
5 4 2 1 5 12 8 10 15 8
1 5
Chốt p = 5 Chốt p = 12
1 4 2 5 5
2 4
Chốt p = 4 xong
1 2 4
Chốt p = 2 xong
1 2
xong xong
Chỉ số 0 1 2 3 4 5 6 7 8 9
Khoá 5 8 2 10 5 12 8 1 15 4
Chốt p = 8
5 4 2 1 5 12 8 10 15 8
1 5 8 12
1 4 2 5 5 8 8 10 15 12
2 4
Chốt p = 4 xong Chốt p = 10 Chốt p = 15

1 2 4 8 8 10
Chốt p = 2 xong xong xong
1 2
xong xong
Chỉ số 0 1 2 3 4 5 6 7 8 9
Khoá 5 8 2 10 5 12 8 1 15 4
Chốt p = 8
5 4 2 1 5 12 8 10 15 8
1 5 8 12
1 4 2 5 5 8 8 10 15 12
2 4 12 15
Chốt p = 4 xong Chốt p = 10 Chốt p = 15

1 2 4 8 8 10 12 15
Chốt p = 2 xong xong xong xong xong
1 2
xong xong
CHƯƠNG TRÌNH SẮP XẾP QUICKSORT
int findPivot_ind(int i, int j){
for (int k=i+1; (k<=j) && a[k]==a[i]; k++);
//Không làm gì cả
if (k>j)
return -1;//không có chốt
else
if (a[k]>a[i])
return k;
else
return i;
}
int partition(int i, int j, int pivot){

int l=i;
int r=j;
while (l<=r) {
while (a[l]<pivot)
l++;
while (a[r]>=pivot)
r--;
if (l<r)
swap(l,r);
}
return l;
Saturday,};
July 22, 2017 Cấu Trúc Dữ Liệu & Giải Thuật CN 40
void QuickSort(int i, int j){

int pivot_ind=findPivot_ind(i,j);
if (pivot_ind!=null){
int pivot=a[pivot_ind];
int k=partition(i,j,pivot);
QuickSort (i,k-1);
QuickSort (k,j);
}
}
HEAPSORT – ĐỊNH NGHĨA HEAP
 Cây sắp thứ tự bộ phận

hay Heap là cây nhị 2
phân mà giá trị tại mỗi

6
nút (khác nút lá) đều 3
không lớn hơn giá trị 5 9 6 7

của các con của nó.
7
 Nhận xét: Nút gốc của 6 9
cây sắp thứ tự bộ phận

có giá trị nhỏ nhất.
HEAPSORT – Ý TƯỞNG GIẢI THUẬT
 Dùng mảng để lưu trữ heap:

 A[1]: gốc
 A[i] có hai con A[2i] & A[2i+1]
 A[i] <=min(A[2i], A[2i+1])
 Xem bảng A[1..n] như

là 1 cây nhị phân:
 A[1]: Nút gốc,  Đổi chổ A[1] và A[n]
 A[i] có hai con  Lặp lại trên A[1..n-1]
A[2i] và A[2i+1] ………………….
 Sắp xếp các pt để có
một heap A[1] nhỏ I.  Thu được dãy có
thứ tự ngược.
HEAPSORT – HÀM PUSHDOWN
 Giả sử A[p],…A[l]  A[p] bị đẩy dần

đã đúng vị trí từ xuống dưới.
pt a[p].
 Tìm phần tử nhỏ
nhất trong 2 con,
 Đổi A[p] với con
bé nhất này nếu
A[p]>con bé nhất,
 Quá trình này kết
thúc khi a[p] đúng
vị trí trong heap.
HEAPSORT – PUSHDOWN CODE
void pushDown (int first, int last){
int r = first;
while (r<=last/2)
if (last==2*r){
if (a[r]>a[last]) swap(r, last);
r=last;//break
}
else
if ((a[r]>a[2*r]) &&
(a[2*r]<=a[2*r+1])){
swap(r,2*r);
r=2*r;
}
HEAPSORT – PUSHDOWN CODE (TT)
else
if ((a[r]>a[2*r+1]) &&
(a[2*r+1]<=a[2*r])){
swap(r,2*r+1);
r=2*r+1;
}
else r=last; //break;
};
CHƯƠNG TRÌNH SẮP XẾP HEAPSORT
void HeapSort(void){
int i;
/*1*/ for(i = (n-2)/2; i>=0; i--)
/*2*/ PushDown(i,n-1); Complexity
/*3*/ for(i = n-1; i>=2; i--) { Xấu nhất
/*4*/ Swap(&a[0],&a[i]); O(nlogn)
/*5*/ PushDown(0,i-1);
}
/*6*/ Swap(&a[0],&a[1]);
}
48

Chuong 4 - Cac Giai Thuat Sap Xep Trong

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Chuong 4 - Cac Giai Thuat Sap Xep Trong

Diunggah oleh

Hak Cipta:

Format Tersedia

CẤU TRÚC DỮ LIỆU & GIẢI THUẬT (CN)

CÁC GIẢI THUẬT

GIẢNG VIÊN: TS. TRƯƠNG QUỐC BẢO

 Giới thiệu bài toán sắp xếp

 Bài toán vận dụng  Danh sách các đối

Sau khi sắp xếp

void swap(int i, int j){  Thủ tục đổi chỗ

Saturday, July 22, 2017 5

 Đơn giản  Nâng cao

Saturday, July 22, 2017 6

 Xét hai phần tử liên tiếp i và j nếu

Saturday, July 22, 2017 7

Chưa sắp  Tại bước thứ i

Saturday, July 22, 2017 8

Saturday, July 22, 2017 9

void selectionSort(int n){

Saturday, July 22, 2017 10

 Giả thiết tại bước thứ i:

 Sắp phần tử thứ i:

Saturday, July 22, 2017 12

void insertionSort(int n){

Thứ tự Thứ tự không đúng

Sau khi nổi bọt Thứ tự Thứ tự đúng

Saturday, July 22, 2017 14

Saturday, July 22, 2017 15

void bubbleSort( int n) {

Saturday, July 22, 2017 16

 Chia mảng làm 2 phần dựa trên phần tử chốt:

Saturday, July 22, 2017 23

 Ðể sắp xếp mảng a[i]..a[j] ta làm các

Chốt p = 4 xong Chốt p = 10 Chốt p = 15

Chốt p = 2 xong xong xong

Chốt p = 4 xong Chốt p = 10 Chốt p = 15

Chốt p = 2 xong xong xong xong xong

int findPivot_ind(int i, int j){

for (int k=i+1; (k<=j) && a[k]==a[i]; k++);

int partition(int i, int j, int pivot){

void QuickSort(int i, int j){

 Cây sắp thứ tự bộ phận

phân mà giá trị tại mỗi

không lớn hơn giá trị 5 9 6 7

cây sắp thứ tự bộ phận

 Dùng mảng để lưu trữ heap:

 Xem bảng A[1..n] như

 Giả sử A[p],…A[l]  A[p] bị đẩy dần

Anda mungkin juga menyukai