CreateHeap(a,n); r=n-1; while(r>0) { hoandoi(a[0],a[r]); r--; if(r>0) Shift(a,0,r); } cout<<"\n Heap sort :\n"; for(int k=0;k
Để chọn được phần tử nhỏ nhất, ta cần duyệt qua n phần tử (tốn n-1 phép so sánh) và sau đó hoán vị nó với phần tử đầu tiên của dãy hiện hành. Để tìm phần tử nhỏ nhất tiếp theo, ta cần duyệt qua n-1 phần tử (tốn n-2 phép so sánh). Cứ như vậy, ta thấy ngay thuật toán sẽ tốn (n-1) + (n-2) + … + 1 = n(n-1)/2 = O(n 2) phép so sánh. Mỗi lần duyệt, ta luôn phải hoán vị 1 lần (1 ( 1 hoán vị tương đương với 3 phép gán), nghĩa là thuật toán sẽ tốn 3(n-1) + 3(n-2) + … + 3 = 3n(n-1)/2 = O(n 2) phép gán.
Tổng kết lại, ta luôn có độ phức tạp của thuật toán Selection Sort thuộc O(n 2 ) trong mọi mọi trường hợp.
INTERCHANGE INTERCHANGE SORT
Thấy ngay số phép so sánh là luôn không đổi, tức không phụ thuộc vào tình trạng ban đầu của dãy. Ta có thể ước lượng số phép so sánh bằng (n-1) + (n-2) + … + 1 = n(n-1)/2 (phần tử thứ i được so sánh với n-i phần tử còn lại.)
Số phép hoán vị (tương đương 3 phép gán) lại phụ thuộc vào tình trạng ban đầu của dãy. Cụ thể như sau: Trường hợp tốt nhất: Dãy ban đầu đã có thứ tự. Ta thấy ngay ta không tốn một o phép hoán vị vị nào. Trường hợp xấu nhất: Dãy ban đầu có thứ tự ngược. Ta thấy ngay mỗi lần so sánh o phần tử thứ i với n-i phần tử còn lại, ta đều phải thực hiện hoán vị. Điều này có nghĩa là số phép hoán vị bằng n(n-1)/2. Tổng kết lại, ta có độ phức tạp của Interchange Sort thuộc O(n2 ) trong mọi trường hợp.
BUBBLE SORT
Thấy ngay số phép so sánh là luôn không đổi, tức không phụ thuộc vào tình trạng ban đầu của dãy. Với i bất kỳ, ta luôn phải so sánh V[j] với V[j-1], mà j chạy từ n đến i+1, tức ta tốn n-i phép so sánh. Thêm nữa, i chạy từ 1 đến n-1. Vậy ta tính được số phép so sánh tổng cộng: ∑(n-i) với i chạy từ 1 đến n-1 = (n-1) + (n-2) + … + 1 = n(n-1)/2.
Số phép hoán vị (tương đương 3 phép gán) lại phụ thuộc vào tình trạng ban đầu của dãy. Cụ thể như sau: Trường hợp tốt nhất: Dãy ban đầu đã có thứ tự. Ta thấy ngay ta không tốn một o phép hoán vị vị nào. Trường hợp xấu nhất: Dãy ban đầu có thứ tự ngược. Xét i bất kỳ, ta thấy rằng mỗi o lần so sánh a[j] với a[j-1], ta đều phải thực hiện hoán vị. Điều này có nghĩa là số phép hoán vị vị bằng n(n-1)/2. n(n-1)/2. Tổng kết lại, ta có độ phức tạp của Bubble Sort thuộc O(n2 ) trong mọi trường hợp.
SHAKER SORT
Ta thấy sự chuyển dời của phần tử không có gì là cải tiến (từ vị trí ban đầu của nó, để đi đến vị trí đúng đều mất chi phí như Bubble Sort).
Chỉ có số phép so sánh là được cải tiến, nhưng chưa tìm được công thức tính số phép so sánh, mặt khác ta thấy chi phí chuyển dời luôn cao hơn (Chi phí hoán vị thường mất 3 phép gán) so sánh nên cải tiến có thể xem như không đáng kể. Thuật toán vẫn được xếp ở O(n2).
INSERTION INSERTION SORT
Ta thấy các phép so sánh xảy ra trong vòng lặp nhằm tìm vị trí thích hợp pos để chèn x. Mỗi lần so sánh mà thấy vị trí đang xét không thích hợp, ta dời phần tử a[pos] sang phải.
Ta cũng thấy số phép gán và số phép so sánh của thuật toán phụ thuộc vào tình trạng của dãy ban đầu. Do đó ta chỉ có thể ước lượng như sau:
Trường hợp tốt nhất: dãy ban đầu đã có thứ tự. Ta tìm được ngay vị trí thích hợp để chèn ngay lần so sánh đầu tiên mà không cần phải vô vòng lặp. Như vậy, với i chạy từ 2 đến n thì số phép so sánh tổng cộng sẽ là n-1. Còn với số phép gán, do thuật toán không chạy vào vòng lặp nên xét i bất kỳ, ta luôn chỉ phải tốn 2 phép gán(x = a[i] và a[pos] = x). Từ đây, ta tính được số phép gán tổng cộng bằng 2(n - 1). Trường hợp xấu nhất: dãy ban đầu có thứ tự ngược. Ta thấy ngay vị trí thích hợp o pos luôn là vị trí đầu tiên của dãy đã có thứ tự, tự, và do đó, để tìm ra vị trí này ta phải duyệt hết dãy đã có thứ tự. Xét i bất kỳ, ta có số phép so sánh là i-1, số phép gán là (i - 1) + 2 = i + 1. Với i chạy từ 2 đến n, ta tính được số phép so sánh tổng cộng bằng 1 + 2 + … + (n - 1) 1) = n(n - 1)/2 và số phép gán gán bằng 3 + 4 + .. + (n + 1) 1) = (n + 4)(n - 1)/2 Tổng kết lại, ta có độ đ ộ phức tạp của Insertion Sort như sau: o
o
Trường hợp tốt nhất: O(n)
o
Trường hợp xấu nhất O(n2 )
BINARY INSERTION INSERTION SORT
Ta nhận thấy rằng cải tiến của thuật toán chỉ giúp việc tìm kiếm nhanh hơn, giảm đi chi phí so sánh trong lúc tìm kiếm, còn chi phí cho việc chèn vẫn không thay đổi (vẫn phải dịch đúng k phần tử như Insertion Sort để chèn) nên chi phí phép gán không có cải tiến.
Tìm kiếm tốt nhất khi vừa tìm phần tử lần đầu là ra ngay, phần tử đó sẽ nằm ở vị trí middle của dãy đã có thứ tự, nhưng chi phí chèn lúc này sẽ là n/2, với chi phí này còn cao so với trường hợp tốt nhất.
Thuật toán chỉ tốt nhất khi chi phí chèn là 1, ứng với phần tử tìm phải nằm ở cuối dãy có thứ tự, chi phí tìm lúc này là log 2n, mà ta phải làm n lần cho n phần tử nên là O(nlogn)
Thuật toán xấu nhất khi phần tử tìm được nằm ở đầu dãy, chi phí chèn lúc này là n (tìm kiếm là log2n, nhưng chi phí chèn mạnh hơn), mà có n phần tử nên là O(n 2).
Ta thấy dường như độ phức tạp thuật toán phụ thuộc mạnh vào chi phí chèn hơn là tìm kiếm, cho nên cách tốt hơn ta sẽ cài đặt bằng danh sách liên kết để việc chèn được tốt hơn.
Độ phức tạp thuật toán như sau: o
Trường hợp tốt nhất: O(nlogn)
o
Trường hợp xấu nhất O(n2 )
HEAP SORT
Ta thấy được chi phí cho xây dựng heap khi thêm vào heap một phần tử mới là log 2n (chính là chiều cao heap cho mỗi lần làm chìm phần tử xuống vị trí thích hợp), mặt khác từ bước 2 đến bước 3 ứng với mỗi phần tử ta sẽ xây dựng lại heap một lần, mà ta có n phần tử. Vậy ta có thể ước tính chi phí cho sắp xếp HeapSort là O(nlogn) cho mọi trường hợp. (Từ thực nghiệm cài đặt cho kết quả là ~ 4log2n)
MERGE SORT SORT
Ta thấy ngay số lần lặp của bước 2(phân phối) và bước 3(trộn) bằng log2n. Ta cũng thấy rằng chi phí thực hiện bước 2 và bước 3 tỉ lệ thuận với n. Như vậy, ta có thể ước tính chi phí thực hiện hiện của giải thuật thuật Merge Sort Sort thuộc O(nlog 2n). n).
Ta nhận thấy rằng giải thuật làm việc một cách cứng nhắc, không tận dụng được tính thứ tự một phần của dãy ban đầu. Do đó, trong mọi trường hợp độ phức tạp là như nhau. Đây là một nhược điểm của phương pháp trộn trực tiếp.
BINARY TREE
Độ phức tạp của thuật toán sort phụ thuộc vào 2 hàm chính là hàm chèn phần tử và duyệt hết các phần tử trong cây.
Đối với hàm chèn phần tử : ta có thể thấy rằng thời gian chạy tỉ lệ thuận với v ới chiều cao của cây -> trường hợp xấu nhất đối với mảng đã sắp, tiêu tốn Ω (n), và O(log n) trong trường hợp trung bình.
Đối với hàm duyệt phần tử: luôn luôn đạt được độ phức tạp tính toán là O(n O(n), vì nó phải duyệt qua tất cả các nút. QUICK SORT
Ta nhận thấy hiệu quả của thuật toán phụ thuộc vào việc chọn giá trị mốc (hay phần tử chốt).
Trường hợp tốt nhất: mỗi lần phân hoạch ta đều chọn được phần tử median (phần tử lớn hơn hay bằng nửa số phần tử và nhỏ hơn hay bằng nửa số phần tử còn lại) làm mốc. Khi đó dãy được phân hoạch thành hai phần bằng nhau, và ta cần log2(n) lần phân hoạch thì sắp xếp xong. Ta cũng dễ nhận thấy trong mỗi lần phân hoạch ta cần duyệt qua n phần tử. Vậy độ phức tạp trong trường hợp tốt nhất thuộc O(nlog2(n)).
Trường hợp xấu nhất: mỗi lần phần hoạch ta chọn phải phần tử có giá trị cực đại hoặc cực tiểu làm mốc. Khi đó dãy bị phân hoạch thành hai phần không đều: một phần chỉ có một phần tử, phần còn lại có n-1 phần phần tử. Do đó, ta cần tới n lần phân phân hoạch mới sắp xếp xong. xong. 2 Vậy độ phức tạp trong trường hợp xấu nhất thuộc O(n ). Tổng kết lại, ta có độ phức tạp của Quick Sort như sau:
Trường hợp tốt nhất: O(nlog 2(n))
Trường hợp xấu nhất: O(n2 ) Trường hợp trung bình: O(nlog 2(n))
SHELL SORT
Yếu tố quyết định chính của thuật toán chính là cách chọn khoảng cách h trong từng bước sắp xếp và số bước sắp xếp k. Nhưng phải thỏa 2 điều kiện sau: -
hi > hi + 1 hk = 1.
Các phần tử h không được là bội số của nhau nhằm tránh hiện tượng mỗi bước sắp thứ tự phải tổ hợp 2 nhóm mà bước trước chúng không hề có ảnh hưởng lẫn nhau. Điều mong muốn là ảnh hưởng giữa các nhóm khác nhau càng nhiều càng tốt.
Việc đánh giá giải thuật Shell sort hiện nay rất phức tạp, thậm chí 1 số chưa được chứng minh. Nhưng có 1 điều chắc chắn là hiệu quả của thuật toán phụ thuộc vào dãy các độ dài được chọn. Trong trường hợp chọn dãy độ dài theo công thức hi = (hi – 1 - 1)/2 và hk = 1, k = log2 - 1 thì giải thuật có độ phức tạp tương đương n1,2 << n2 .
Có thể nói đây còn là 1 bài toán mở vì trên lý thuyết vẫn tồn tại các dãy có thể đem lại tốc độ tối ưu hơn cho bài toán.
