2.3 Các phương pháp tìm kiếm nội
Có 2 giải thuật thường được áp dụng để tìm kiếm dữ liệu là tìm tuyến tính và tìm nhị phân
2.3.1 Tìm kiếm tuyến tính
Giải thuật
Tìm tuyến tính là một kỹ thuật tìm kiếm rất đơn giản và cổ điển. Thuật toán tiến hành so sánh x lần lượt với phần tử thứ nhất, thứ hai, ... của mảng a cho đến khi gặp được phần tử có khóa cần tìm, hoặc đã tìm hết mảng mà không thấy x. Các bước tiến hành như sau :
PHP Code:
• Bước 1:
i = 1; // bắt đầu từ phần tử đầu tiên của dãy
• Bước 2: So sánh a[i] với x, có 2 khả năng :
o a[i] = x : Tìm thấy. Dừng
o a[i] != x : Sang Bước 3.
• Bước 3 :
i = i+1; // xét tiếp phần tử kế trong mảng
Nếu i >N: Hết mảng, không tìm thấy.Dừng
Ngược lại: Lặp lại Bước 2.
Ví dụ : cho dãy số a: 12 2 8 5 1 6 4 15
Nếu giá trị cần tìm là 8, giải thuật được tiến hành như sau :
Hình 2.2
i = 1
Hình 2.3
i = 2
i = 3 Dừng
Cài đặt
Từ mô tả trên đây của thuật toán tìm tuyến tính , có thể cài đặt hàm LinearSearch để xác định vị trí của phần tử có khoá x trong mảng a :
int LinearSearch(int a[], int N, int x)
{ int i=0;
while ((i<N) && (a[i]!=x )) i++;
if(i==N) return -1; // tìm hết mảng nhưng không có x
else return i; // a[i] là phần tử có khoá x
}
Trong cài đặt trên đây, nhận thấy mỗi lần lặp của vòng lặp while phải tiến thành kiểm tra 2 điều kiện (i<N) - điều kiện biên của mảng - và (a[i]!=x )- điều kiện kiểm tra chính. Nhưng thật sự chỉ cần kiểm tra điều kiện chính(a[i] !=x), để cải tiến cài đặt, có thể dùng phương pháp "lính canh" - đặt thêm một phần tử có giá trị x vào cuối mảng, như vậy bảo đảm luôn tìm thấy x trong mảng, sau đó dựa vào vị trí tìm thấy để kết luận. Cài đặt cải tiến sau đây của hàm LinearSearch giúp giảm bớt một phép so sánh trong vòng lặp :
int LinearSearch(int a[],int N,int x)
{ int i=0; // mảng gồm N phần tử từ a[0]..a[N-1]
a[N] = x; // thêm phần tử thứ N+1
while (a[i]!=x ) i++;
if (i==N)
return -1; // tìm hết mảng nhưng không có x
else
return i; // tìm thấy x tại vị trí i
}
Ðánh giá giải thuật
Có thể ước lượng độ phức tạp của giải thuật tìm kiếm qua số lượng các phép so sánh được tiến hành để tìm ra x. Trường hợp giải thuật tìm tuyến tính, có:
Trường hợp Số lần so sánh Giải thích
Tốt nhất 1 Phần tử đầu tiên có giá trị x
Xấu nhất n+1 Phần tử cuối cùng có giá trị x
Trung bình (n+1)/2 Giả sử xác suất các phần tử trong mảng nhận giá trị x là như nhau.
Vậy giải thuật tìm tuyến tính có độ phức tạp tính toán : T(n) = O(n)
NHẬN XÉT
Giải thuật tìm tuyến tính không phụ thuộc vào thứ tự của các phần tử mảng, do vậy đây là phương pháp tổng quát nhất để tìm kiếm trên một dãy số bất kỳ.
Một thuật toán có thể được cài đặt theo nhiều cách khác nhau, kỹ thuật cài đặt ảnh hưởng đến tốc độ thực hiện của thuật toán.
2.3.2 Tìm kiếm nhị phân
Giải thuật
Ðối với những dãy số đã có thứ tự ( giả sử thứ tự tăng ), các phần tử trong dãy có quan hệ ai -1 £ ai £ ai+1, từ đó kết luận được nếu x > ai thì x chỉ có thể xuất hiện trong đoạn
[ai+1 ,aN] của dãy , ngược lại nếu x < ai thì x chỉ có thể xuất hiện trong đoạn [a1 ,ai-1] của dãy . Giải thuật tìm nhị phân áp dụng nhận xét trên đây để tìm cách giới hạn phạm vi tìm kiếm sau mỗi lần so sánh x với một phần tử trong dãy. Ý tưởng của giải thuật là tại mỗi bước tiến hành so sánh x với phần tử nằm ở vị trí giữa của dãy tìm kiếm hiện hành, dựa vào kết quả so sánh này để quyết định giới hạn dãy tìm kiếm ở bước kế tiếp là nửa trên hay nửa dưới của dãy tìm kiếm hiện hành. Giả sử dãy tìm kiếm hiện hành bao gồm các phần tử aleft .. aright , các bước tiến hành như sau :
PHP Code:
Bước 1: left = 1; right = N; // tìm kiếm trên tất cả các phần tử
Bước 2:
• mid = (left+right)/2; // lấy mốc so sánh
• So sánh a[mid] với x, có 3 khả năng :
o a[mid] = x: Tìm thấy. Dừng
o a[mid] > x: //tìm tiếp x trong dãy con aleft .. amid -1 :
o right =midle - 1;
a[mid] < x: //tìm tiếp x trong dãy con amid +1 .. aright :
left = mid + 1;
Bước 3:
• Nếu left right //còn phần tử chưa xét, tìm tiếp.
Lặp lại Bước 2.
• Ngược lại: Dừng; //Ðã xét hết tất cả các phần tử.
Ví dụ : Cho dãy số a gồm 8 phần tử:
1 2 4 5 6 8 12 15
Nếu giá trị cần tìm là 8, giải thuật được tiến hành như sau:
left = 1, right = 8, midle = 4
left = 5, right = 8, midle = 6 Dừng
Cài đặt
Thuật toán tìm nhị phân có thể được cài đặt thành hàm BinarySearch:
int BinarySearch(int a[],int N,int x )
{ int left =0; right = N-1;
int midle;
do {
mid = (left + right)/2;
if (x = a[midle]) return midle;//Thấy x tại mid else
if (x < a[midle]) right = midle -1;
else left = midle +1;
}while (left <= right);
return -1; // Tìm hết dãy mà không có x
}
Ðánh giá giải thuật
Trường hợp giải thuật tìm nhị phân, có bảng phân tích sau :
Trường hợp Số lần so sánh Giải thích
Tốt nhất 1 Phần tử giữa của mảng có giá trị x
Xấu nhất log 2 n Không có x trong mảng
Trung bình log 2 (n/2) Giả sử xác suất các phần tử trong mảng nhận giá trị x là như nhau
Vậy giải thuật tìm nhị phân có độ phức tạp tính toán : T(n) = O(log 2 n)
NHẬN XÉT
Giải thuật tìm nhị phân dựa vào quan hệ giá trị của các phần tử mảng để định hướng trong quá trình tìm kiếm, do vậy chỉ áp dụng được cho những dãy đã có thứ tự.
Giải thuật tìm nhị phân tiết kiệm thời gian hơn rất nhiều so với giải thuật tìm tuyến tính do Tnhị phân (n) = O(log2n) < Ttuyến tính (n) = O(n).
Tuy nhiên khi muốn áp dụng giải thuật tìm nhị phân cần phải xét đến thời gian sắp xếp dãy số để thỏa điều kiện dãy số có thứ tự. Thời gian này không nhỏ, và khi dãy số biến động cần phải tiến hành sắp xếp lại . Tất cả các nhu cầu đó tạo ra khuyết điểm chính cho giải thuật tìm nhị phân. Ta cần cân nhắc nhu cầu thực tế để chọn một trong hai giải thuật tìm kiếm trên sao cho có lợi nhất
2.4 Các phương pháp sắp xếp nội
Sắp xếp là quá trình xử lý một danh sách các phần tử (hoặc các mẫu tin) để đặt chúng theo một thứ tự thỏa mãn một tiêu chuẩn nào đó dựa trên nội dung thông tin lưu giữ tại mỗi phần tử
Sắp xếp dãy số a1 , a2 ,... ,aN là thực hiện việc bố trí lại các phần tử sao cho hình thành được dãy mới ak1 , ak2 ,... ,akN có thứ tự ( giả sử xét thứ tự tăng) nghĩa là aki £ aki-1. Mà để quyết định được những tình huống cần thay đổi vị trí các phần tử trong dãy, cần dựa vào kết quả của một loạt phép so sánh. Chính vì vậy, hai thao tác so sánh và gán là các thao tác cơ bản của hầu hết các thuật toán sắp xếp.
2.4.1 Các phương pháp sắp xếp có độ phức tạp N2
2.4.1.1 Phương pháp chọn trực tiếp (SelectionSort)
Giải thuật
Ta thấy rằng, nếu mảng có thứ tự, phần tử ai luôn là min(ai, ai+1, ., an-1). Ý tưởng của thuật toán chọn trực tiếp mô phỏng một trong những cách sắp xếp tự nhiên nhất trong thực tế: chọn phần tử nhỏ nhất trong N phần tử ban đầu, đưa phần tử này về vị trí đúng là đầu dãy hiện hành; sau đó không quan tâm đến nó nữa, xem dãy hiện hành chỉ còn N-1 phần tử của dãy ban đầu, bắt đầu từ vị trí thứ 2; lặp lại quá trình trên cho dãy hiện hành... đến khi dãy hiện hành chỉ còn 1 phần tử. Dãy ban đầu có N phần tử, vậy tóm tắt ý tưởng thuật toán là thực hiện N-1 lượt việc đưa phần tử nhỏ nhất trong dãy hiện hành về vị trí đúng ở đầu dãy. Các bước tiến hành như sau :
PHP Code:
Bước 1: i = 1;
Bước 2: Tìm phần tử a[min] nhỏ nhất trong dãy hiện hành từ a[i] đến a[N]
Bước 3 : Hoán vị a[min] và a[i]
Bước 4 : Nếu i £ N-1 thì i = i+1; Lặp lại Bước 2
Ngược lại: Dừng. //N-1 phần tử đã nằm đúng vị trí.
Ví dụ
Cho dãy số a: 12 2 8 5 1 6 4 15
Cài đặt
Cài đặt thuật toán sắp xếp chọn trực tiếp thành hàm SelectionSort
void SelectionSort(int a[],int N )
{ int min; // chỉ số phần tử nhỏ nhất trong dãy hiện 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ử hiện nhỏ nhất
Hoanvi(a[min], a[i]);
}
}
Ðánh giá giải thuật
Ðối với giải thuật chọn trực tiếp, có thể thấy rằng ở lượt thứ i, bao giờ cũng cần (n-i) lần so sánh để xác định phần tử nhỏ nhất hiện hành. Số lượng phép so sánh này không phụ thuộc vào tình trạng của dãy số ban đầu, do vậy trong mọi trường hợp có thể kết luận :
Số lần so sánh =
Số lần hoán vị (một hoán vị bằng 3 phép gán) lại phụ thuộc vào tình trạng ban đầu của dãy số, ta chỉ có thể ước lược trong từng trường hợp như sau :
Trường hợp Số lần so sánh Số phép gán
Tốt nhất n(n-1)/2 0
Xấu nhất n(n-1)/2 3n(n-1)/2
2.4.1.2 Phương pháp Chèn trực tiếp (InsertionSort)
Giải thuật
Giả sử có một dãy a1 , a2 ,... ,an trong đó i phần tử đầu tiên a1 , a2 ,... ,ai-1 đã có thứ tự. Ý tưởng chính của giải thuật sắp xếp bằng phương pháp chèn trực tiếp là tìm cách chèn phần tử ai vào vị trí thích hợp của đoạn đã được sắp để có dãy mới a1 , a2 ,... ,ai trở nên có thứ tự. Vị trí này chính là vị trí giữa hai phần tử ak-1 và ak thỏa ak-1 £ ai < ak (1£k£i).
Cho dãy ban đầu a1 , a2 ,... ,an, ta có thể xem như đã có đoạn gồm một phần tử a1 đã được sắp, sau đó thêm a2 vào đoạn a1 sẽ có đoạn a1 a2 được sắp; tiếp tục thêm a3 vào đoạn a1 a2 để có đoạn a1 a2 a3 được sắp; tiếp tục cho đến khi thêm xong aN vào đoạn a1 a2 ...aN-1 sẽ có dãy a1 a2.... aN được sắp. Các bước tiến hành như sau :
PHP Code:
Bước 1: i = 2; // giả sử có đoạn a[1] đã được sắp
Bước 2: x = a[i];
Tìm vị trí pos thích hợp trong đoạn a[1] đến a[i-1] để chèn a[i] vào
Bước 3: Dời chỗ các phần tử từ a[pos] đến a[i-1] sang phải 1 vị trí để dành chỗ cho a[i]
Bước 4: a[pos] = x; // có đoạn a[1]..a[i] đã được sắp
Bước 5: i = i+1;
Nếu i £ n : Lặp lại Bước 2.
Ngược lại : Dừng.
Ví dụ
Cho dãy số a: 12 2 8 5 1 6 4 15
Dừng
Cài đặt
Cài đặt thuật toán sắp xếp chèn trực tiếp thành hàm InsertionSort
void InsertionSort(int a[], int N )
{ int pos, i;
int x; //lưu giá trị a[i] tránh bị ghi đè khi dời chỗ các phần tử.
for(int i=1 ; i<N ; i++) //đoạn a[0] đã sắp
{
x = a[i]; pos = i-1;
// tìm vị trí chèn x
while((pos >= 0)&&(a[pos] > x))
{// kết hợp dời chỗ các phần tử sẽ đứng sau x trong dãy mới
a[pos+1] = a[pos];
pos--;
}
a[pos+1] = x]; // chèn x vào dãy
}
}
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], do đoạn đã được sắp, nên có thể sử dụng giải thuật tìm nhị phân để thực hiện việc tìm vị trí pos, khi đó có giải thuật sắp xếp chèn nhị phân :
void BInsertionSort(int a[], int N )
{ int l,r,m,i;
int x; //lưu giá trị a[i] tránh bị ghi đè khi dời chỗ các phần tử.
for(int i=1 ; i<N ; i++)
{ x = a[i]; l = 1; r = i-1;
while(i<=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-1 ; j >=l ; j--)
a[j+1] = a[j]; // dời các phần tử sẽ đứng sau x
a[l] = x; // chèn x vào dãy
}
}
Đánh giá giải thuật
Ðối với giải thuật chèn trực tiếp, các phép so sánh xảy ra trong mỗi vòng lặp while tìm vị trí thích hợp pos, và mỗi lần xác định vị trí đang xét không thích hợp, sẽ dời chỗ phần tử a[pos] tương ứng. Giải thuật thực hiện tất cả N-1 vòng lặp while , do số lượng phép so sánh và dời chỗ này phụ thuộc vào tình trạng của dãy số ban đầu, nên chỉ có thể ước lược trong từng trường hợp như sau :
Trường hợp Số phép so sánh Số phép gán
Tốt nhất
Xấu nhất
2.4.1.3 Phương pháp đổi chỗ trực tiếp (InterchangeSort)
Giải thuật
PHP Code:
Bước 1 : i = 1;// bắt đầu từ đầu dãy
Bước 2 : j = i+1;//tìm các phần tử a[j] < a[i], j>i
Bước 3 : Trong khi j £ N thực hiện
Nếu a[j]<a[i]: a[i]«a[j]; //xét cặp a[i], a[j]
j = j+1;
Bước 4 : i = i+1;
Nếu i < n: Lặp lại Bước 2.
Ngược lại: Dừng.
Ví dụ : Cho dãy số a: 12 2 8 5 1 6 4 15
Cài đặt
Cài đặt thuật toán sắp xếp theo kiểu đổi chỗ trực tiếp thành hàm InterchangeSort:
void InterchangeSort(int a[], int N )
{ int i, j;
for (i = 0 ; i<N-1 ; i++)
for (j =i+1; j < N ; j++)
if(a[j ]< a[i]) // nếu có sự sai vị trí thì đổi chỗ
Hoanvi(a[i],a[j]);
}
Ðánh giá giải thuật
Ðối với giải thuật đổi chỗ trực tiếp, số lượng các phép so sánh xảy ra không phụ thuộc vào tình trạng của dãy số ban đầu, nhưng số lượng phép hoán vị thực hiện tùy thuộc vào kết qủa so sánh, có thể ước lược trong từng trường hợp như sau :
Trường hợp Số lần so sánh Số lần hoán vị
Tốt nhất
0
Xấu nhất
2.4.1.4 Phương pháp nổi bọt (Bubble sort)
Giải thuật
Ý tưởng chính của giải thuật là xuất phát từ cuối (đầu) dãy, đổi chỗ các cặp phần tử kế cận để đưa phần tử nhỏ (lớn) hơn trong cặp phần tử đó về vị trí đúng đầu (cuối) dãy hiện hành, sau đó sẽ không xét đến nó ở bước tiếp theo, do vậy ở lần xử lý thứ i sẽ có vị trí đầu dãy là i . Lặp lại xử lý trên cho đến khi không còn cặp phần tử nào để xét. Các bước tiến hành như sau :
PHP Code:
Bước 1 : i = 1; // lần xử lý đầu tiên
Bước 2 : j = N; //Duyệt từ cuối dãy ngược về vị trí i
Trong khi (j < i) thự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 3 : i = i+1; // lần xử lý kế tiếp
Nếu i >N-1: Hết dãy. Dừng
Ngược lại : Lặp lại Bước 2.
Ví dụ
Cho dãy số a: 12 2 8 5 1 6 4 15
Cài đặt
Cài đặt thuật toán sắp xếp theo kiểu nổi bọt thành hàm BubbleSort:
void BubleSort(int a[], int N )
{ int i, j;
for (i = 0 ; i<N-1 ; i++)
for (j =N-1; j >i ; j --)
if(a[j]< a[j-1]) // nếu sai vị trí thì đổi chỗ
Hoanvi(a[j],a[j-1]);
}
Ðánh giá giải thuật
Ðối với giải thuật nổi bọt, số lượng các phép so sánh xảy ra không phụ thuộc vào tình trạng của dãy số ban đầu, nhưng số lượng phép hoán vị thực hiện tùy thuộc vào kết qủa so sánh, có thể ước lược trong từng trường hợp như sau :
Trường hợp Số lần so sánh Số lần hoán vị
Tốt nhất
0
Xấu nhất
Nhận xét
BubbleSort có các khuyết điểm sau: không nhận diện được tình trạng dãy đã có thứ tự hay có thứ tự từng phần. Các phần tử nhỏ được đưa về vị trí đúng rất nhanh, trong khi các phần tử lớn lại được đưa về vị trí đúng rất chậm.
2.4.1.5 Phương pháp nổi bọt cải tiến (Shake sort)
Giải thuật
Giải thuật sắp xếp ShakerSort cũng dựa trên nguyên tắc đổi chỗ trực tiếp, nhưng tìm cách khắc phục các nhược điểm của BubleSort với những ý tưởng cải tiến chính như sau :
Trong mỗi lần sắp xếp, duyệt mảng theo 2 lượt từ 2 phiá khác nhau :
+ Lượt đi: đẩy phần tử nhỏ về đầu mảng
+ Lượt về: đẩy phần tử lớn về cuối mảng
Ghi nhận lại những đoạn đã sắp xếp nhằm tiết kiệm các phép so sánh thừa.
Các bước tiến hành như sau :
Ý tưởng chính của giải thuật là xuất phát từ cuối (đầu) dãy, đổi chỗ các cặp phần tử kế cận để đưa phần tử nhỏ (lớn) hơn trong cặp phần tử đó về vị trí đúng đầu (cuối) dãy hiện hành, sau đó sẽ không xét đến nó ở bước tiếp theo, do vậy ở lần xử lý thứ i sẽ có vị trí đầu dãy là i . Lặp lại xử lý trên cho đến khi không còn cặp phần tử nào để xét. Các bước tiến hành như sau :
PHP Code:
Bước 1 :
l = 1; r = n; //từ l đến r là đoạn cần được sắp xếp
k = n; // ghi nhận vị trí k xảy ra hoán vị sau cùng
// để làm cơ sở thu hẹp đoạn l đến r
Bước 2 :
Bước 2a :
j = r ; // đẩy phần tử nhỏ về đầu mảng
Trong khi (j > l) :
Nếu a[j]<a[j-1]: a[j] « a[j-1];
k = j; //lưu lại nơi xảy ra hoán vị
j = j - 1;
l = k; //loại các phần tử đã có thứ tự ở đầu dãy
Bước 2b :
j = l ; // đẩy phần tử lớn về cuối mảng
Trong khi (j < r) :
Nếu a[j]>a[j+1]:a[j] « a[j+1];
k = j; //lưu lại nơi xảy ra hoán vị
j = j+1;
r = k; //loại các phần tử đã có thứ tự ở cuối dãy
Bước 3 : Nếu l < r: Lặp lại Bước 2.
Ví dụ
Cho dãy số a: 12 2 8 5 1 6 4 15
Cài đặt
Cài đặt thuật toán sắp xếp theo kiểu nổi bọt cải tiến thành hàm ShakeSort:
void ShakeSort(int a[], int N )
{ int i, j;
int left, right, k;
left = 0; right = n-1; k = n-1;
while (left < right)
{
for (j = right; j > left; j --)
{
if ( a[j]< a[j-1]) // sai vị trí thì đổi chỗ
{ Hoanvi(a[j],a[j-1]);
k = j;
}
}
left = k;
for (j = left; j < right; j ++)
{
if (a[j]> a[j+1]) // sai vị trí thì đổi chỗ
{ Hoanvi(a[j],a[j-1]);
k = j;
}
}
right = k;
}
}
Học trực tuyến những điều cơ bản về CTDL các bạn ơi
Nguyên bản được gửi bởi huynguyen
