Các phương pháp sắp xếp cơ bản

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

•  Giải thuật

Ta thấy rằng, nếu mảng có thứ tự, phần tử a_i luôn là min(a_i, a_i+1, ., a_n-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 :

• 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

 

Phương pháp Chèn trực tiếp

•        Giải thuật

Giả sử có một dãy a1 , a2 ,... ,an trong đó iphầ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-1và 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 :

• 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 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

 

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 :

• 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;               }}