Báo cáo BTL PTTK Giải Thuật Sorting and Searching

TỔNG LIÊN ĐOÀN LAO ĐỘNG VIỆT NAM
TRƯỜNG ĐẠI HỌC TÔN ĐỨC THẮNG
KHOA CÔNG NGHỆ THÔNG TIN




Môn: Phân tích thiết kế & giải thuật
Đề tài: Sorting and Searching

GVHD : ThS. Võ Đức Vĩnh
SVTH : Nguyễn Văn Thanh
Lớp : 12050301
MSSV : 51203124


TP.Hồ Chí Minh, Ngày 01 Tháng 04 Năm 2015



Trang 2



LỜI NÓI ĐẦU
Khái niệm sắp xếp dường như đã gắn liền với xã hội loài người từ thuở ban đầu của nền
văn minh. Nó đơn giản thể hiện trong việc sắp hàng, trong việc phân công công việc, …
Ngày nay, trong một thế giới mà khoa học công nghệ mỗi ngày phát triển như vũ bão và
nhu cầu khai thác, tìm kiếm thông tin của con người ngày càng cao thì việc nâng cao tính
hiệu quả của các giải thuật sắp xếp cũng ngày càng trở nên quan trọng.
Trong hầu hết các hệ lưu trữ, quản lý dữ liệu thao tác tìm kiếm là thao tác cơ bản để

khai thác thông tin. Để việc tìm kiếm trở nên hiệu quả và nhanh chóng thì dữ liệu trong hệ
thống cần được tổ chức theo một trật tự nào đó và điều này đòi hỏi chúng ta phải xây dựng
những giải thuật sắp xếp thích hợp.
Bài báo cáo này nhằm mục đích giới thiệu về Sorting & Searching. Hy vọng nhận được
những nhận xét và đánh giá chân thành từ thầy và các bạn.



Trang 3



ĐỒ ÁN ĐƯỢC HOÀN THÀNH
TẠI TRƯỜNG ĐẠI HỌC TÔN ĐỨC THẮNG

Tôi xin cam đoan đây là sản phẩm đồ án của riêng tôi và được sự hướng dẫn của
ThS. Võ Đức Vĩnh. Các nội dung nghiên cứu, kết quả trong đề tài này là trung thực và
chưa công bố dưới bất kỳ hình thức nào trước đây. Những số liệu trong các bảng biểu phục
vụ cho việc phân tích, nhận xét, đánh giá được chính tác giả thu thập từ các nguồn khác
nhau có ghi rõ trong phần tài liệu tham khảo.
Ngoài ra, trong đồ án còn sử dụng một số nhận xét, đánh giá cũng như số liệu của
các tác giả khác, cơ quan tổ chức khác đều có trích dẫn và chú thích nguồn gốc.
Nếu phát hiện có bất kỳ sự gian lận nào tôi xin hoàn toàn chịu trách nhiệm về
nội dung đồ án của mình. Trường đại học Tôn Đức Thắng không liên quan đến những vi
phạm tác quyền, bản quyền do tôi gây ra trong quá trình thực hiện (nếu có).
TP. Hồ Chí Minh, ngày 01 tháng 04 năm 2015
Tác giả
Nguyễn Văn Thanh

Trang 4



PHẦN XÁC NHẬN VÀ ĐÁNH GIÁ CỦA GIẢNG VIÊN
Phần xác nhận của GV hướng dẫn
__________________________________________________________
__________________________________________________________
__________________________________________________________
__________________________________________________________
__________________________________________________________
__________________________________________________________
___________________________________________________
Tp. Hồ Chí Minh, ngày tháng năm
(kí và ghi họ tên)



Phần đánh giá của GV chấm bài
__________________________________________________________
__________________________________________________________
__________________________________________________________
__________________________________________________________
__________________________________________________________
__________________________________________________________
___________________________________________________
Tp. Hồ Chí Minh, ngày tháng năm
(kí và ghi họ tên)

Trang 5



Mục Lục
LỜI NÓI ĐẦU 1
PHẦN XÁC NHẬN VÀ ĐÁNH GIÁ CỦA GIẢNG VIÊN 4
Phần I: Sorting 6
I. Lý thuyết – Thuật toán: 6
1. Selection sort: 6
2. Insertion sort: 7
3. Bubble sort: 8
4. Merge sort: 10
5. Quick sort : 12
6. Heap sort : 17
7. Radix sort: 19
II. Môi trường thực nghiệm: 23
1. Cấu hình máy thực nghiệm: 23
2. Cấu trúc dữ liệu thực nghiệm: Mảng (Array[]) 23
3. Kiểu dữ liệu thực nghiệm: Integer. 23
4. Hàm tính thời gian trong c#: 25
III. Thực nghiệm: 25
1. Insertion sort: 25
2. Selection sort: 27
3. Bubble sort: 29
4. Merge sort: 30
5. Quick sort: 32

6. Heap sort: 36
7. Radix sort: 37
IV. Nhận xét kết quả Lý thuyết – Thực nghiệm: 39
Phần 2: Searching 41
I. Cở sở lý thuyết về Brute – Force: 41
II. Thuật toán tìm kiếm Chia để trị: 42
III. Thực nghiệm: 43




Trang 6



Phần I: Sorting
I. Lý thuyết – Thuật toán:
1. Selection sort:
- Ý tưởng:
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 tiên
của 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 thực hiện:
Giả sử ta có mảng a[0 n-1].
Bước 1: Cho i là số đếm bằng 0, i=0.
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-1]
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í.
Hình 1: Selection sort.
- Cài đặt thuật toán:




Trang 7



- Phân tích độ phức tạp:
Nếu có n phần tử thì O= (n-1) + (n-2) + = n*(n-1)/2 = O(n^2).
Thuật toán sẽ nhanh hơn khi mảng đã sắp xếp một phần.
2. Insertion sort:
- Ý tưởng:
Sắp xếp chèn (insertion sort) là một thuật toán sắp xếp bắt chước cách sắp xếp quân bài
của những người chơi bài. Muốn sắp một bộ bài theo trật tự người chơi bài rút lần lượt từ quân
thứ 2, so với các quân đứng trước nó để chèn vào vị trí thích hợp.
- Thuật toán:
Giả sử ta có mảng a[0 n-1].
Bước 1: Xem mảng gồm 1 phần tử là a0 dãy có
thứ tự.
Bước 2: Thêm a1 vào mảng có thứ tự a0 sao cho
mảng mới a[0, 1] là mảng có thứ tự. Nếu a[1] <
a[0] ta hoán vị a[1] với a[0].
Bước 3: Thêm a[2] vào mảng có thứ tự a[0], a[1]
sao cho mảng mới a[0,1,2] là mảng có thứ tự.
Tiếp tục như thế đến n-1 bước ta sẽ có mảng có

thứ tự a[0 n-1].
Hình 2: Insertion sort.
- Cài đặt thuật toán:




Trang 8



- Phân tích độ phức tạp:
Thuật toán sử dụng trung bình n^2/4 phép so sánh và n^2/4 lần hoán vị, n^2/2 phép so sánh và
n^2/2 lần hoán vị trong trường hợp xấu nhất, n-1 phép so sánh và 0 lần hoán vị trong trường
hợp tốt nhất.
 BigO = O(n^2)
Thuật toán thích hợp đối với mảng đã được sắp xếp một phần hoặc mảng có kích thước nhỏ.
3. Bubble sort:
Sắp xếp nổi bọt (Bubble sort) là một thuật toán sắp xếp đơn giản, với thao tác cơ bản là so
sánh hai phần tử kề nhau, nếu chúng chưa đứng đúng thứ tự thì đổi chỗ (swap). Có thể tiến
hành từ trên xuống (bên trái sang) hoặc từ dưới lên (bên phải sang). Sắp xếp nổi bọt còn có tên
là sắp xếp bằng so sánh trực tiếp. Nó sử dụng phép so sánh các phần tử nên là một giải thuật
sắp xếp kiểu so sánh.
- Ý tưởng thuật toán:
Giả sử ta có mảng a[0 n-1].
+ Sắp xếp từ phải sang: Bắt đầu từ việc so sánh cặp phần tử thứ n-1 và n. Tiếp theo là so sánh
cặp phần tử thứ n-2 và n-1 cho đến khi so sánh và đổi chỗ cặp phần tử thứ nhất và thứ hai.
Sau bước này phần tử nhỏ nhất đã được nổi lên vị trí trên cùng (nó giống như hình ảnh của các
"bọt" khí nhẹ hơn được nổi lên trên). Tiếp theo tiến hành với các phần tử từ thứ 2 đến thứ n.

Hình 3: Bubble sort.
+ Giảm bớt vòng duyệt: Nếu trong một lần duyệt nào đó với một i cố định khi vòng lặp j kết
thúc mà không cần phải đổi chỗ cặp phần tử nào, nghĩa là mọi cặp phần tử kề nhau đã đứng



Trang 9



đúng thứ tự thì dãy đã được sắp xếp và không cần tiến hành vòng lặp tiếp theo. Do đó có thể
dùng một cờ để kiểm soát việc này.
- Cài đặt thuật toán:


- Phân tích độ phức tạp:
Với mỗi i = 0, 1, 2, , n-1 ta cần i phép so sánh. Do đó số nhiều nhất các lần so sánh và đổi
chỗ trong giải thuật là:
(n - 1) + (n - 2) + + 2 + 1 = (n*(n - 1))/n
 BigO: O(n^2)



Trang 10




4. Merge sort:
Là một thuật toán sắp xếp để sắp xếp các danh sách (hoặc bất kỳ cấu trúc dữ liệu nào có

thể truy cập tuần tự, vd: Array[]) theo một trật tự nào đó. Thuật toán này là một ví dụ tương
đối điển hình của lối thuật toán chia để trị. Nó được xếp vào thể loại sắp xếp so sánh.
- Ý tưởng thuật toán:
+ Thuật toán Merge Sort cho không gian cần sắp xếp thành 2 không gian con.
+ Nếu không gian con thứ 1 có nhiều hơn 1 phần tử thì sắp xếp không gian con này bằng thuật
toán Merge Sort.
+ Nếu không gian con thứ 2 có nhiều hơn 1 phần tử thì sắp xếp không gian con này bằng thuật
toán Merge Sort.
+ Trộn 2 không gian con đã được sắp xếp lại với nhau.

Hình 4: Merge Sort.
- Cài đặt thuật toán:



Trang 11





- Phân tích độ phức tạp thuật toán:
Ta có mảng a[0,1,…n-1], theo thuật toán ta sẽ có 2 mảng:
+ Mảng 1: có k phần tử (hay n/2).
+ Mảng 2: có n – k phần tử (hay n/2).
 T(n) = T(k) + T(n-k) + cn (1)
Với :
+ T(k) là thời gian sắp xếp mảng k phần tử.
+ T(n-k) là thời gian sắp xếp mảng với n – k phần tử.

Trang 12



+ cn là tổng thời gian sắp xếp lại mảng a.
Giải (1) theo hệ thức truy hồi ta có :
T(n) = 2T(n/2) + cn (2)
 T(n/2) = 2T(n/4) +c(n/2)
 T(n/4) = 2T(n/8) + c/(n/4)
Khi đó ta có (2) là:
T(n) = 2(2T(n/4) + c(n/2)) + cn = 4T(n/4) + 2cn
= 2(2(2T(n/8) + c(n/4)) + c(n/2)) + cn = 8T(n/8) + 3cn
= 2^3T(n/2^3) + 3cn
….
= 2^kT(n/2^k) + kcn (3)
ĐK dừng khi t(1), khi đó
n = 2^k => k = logn (lưu ý log cơ số 2).
Thế k vào (3) ta được :
(3)  2^lognT(1) + logn(cn) = nT(1) + c(nlogn)
 BigO : O(nlogn)
- Ưu – nhược điểm của thuật toán :
Ưu điểm
Nhược điểm
Ổn định
Tốn bộ nhớ đệm
Thời gian : O (nlogn)

5. Quick sort :
- Khái niệm :
Là một thuật toán sắp xếp phát triển bởi C.A.R. Hoare, dựa trên phép phân chia danh sách
được sắp thành hai danh sách con. Khác với sắp xếp trộn, chia danh sách cần sắp xếp a[0, 1 n-
1] thành hai danh sách con có kích thước tương đối bằng nhau nhờ chỉ số đứng giữa danh sách,
sắp xếp nhanh chia nó thành hai danh sách bằng cách so sánh từng phần tử của danh sách với



Trang 13



một phần tử được chọn được gọi là phần tử chốt. Những phần tử nhỏ hơn hoặc bằng phần tử
chốt được đưa về phía trước và nằm trong danh sách con thứ nhất, các phần tử lớn hơn chốt
được đưa về phía sau và thuộc danh sách đứng sau. Cứ tiếp tục chia như vậy tới khi các danh
sách con đều có độ dài bằng 1.
- Phần tử chốt (pivot):
Kỹ thuật chọn phần tử chốt ảnh hưởng khá nhiều đến khả năng rơi vào các vòng lặp vô hạn
đối với các trường hợp đặc biệt. Tốt nhất là chọn phần tử chốt là trung vị của danh sách. Khi
đó sau log(n) lần phân chia ta sẽ đạt tới kích thước danh sách bằng 1. Tuy nhiên điều đó rất
khó. Có các cách chọn phần tử chốt như sau:
+ Chọn phần tử đứng đầu hoặc đứng cuối làm phần tử chốt.
+ Chọn phần tử đứng giữa danh sách làm phần tử chốt.
+ Chọn phần tử trung vị trong 3 phần tử đứng đầu, đứng giữa và đứng cuối làm phần tử chốt.
+ Chọn phần tử ngẫu nhiên làm phần tử chốt.

Hình 5: Quick Sort.
- Ý tưởng thuật toán:
Giả sử ta có mảng a[0,1,…n-1]

+ Thuật toán Quick Sort chia mảng cần sắp xếp thành 2 mảng con là mảng con thứ 1 và mảng
con thứ 2. Bằng cách sử dụng phần tử chốt (pivot).
+ Mảng con thứ 1: Các ptử thuộc mảng này đều nhỏ hơn tất cả các phần tử thuộc mảng con 2.
+ Nếu mảng con thứ 1 có nhiều hơn 1 ptử thì sort mảng con này bằng thuật toán Quick Sort.
+ Nếu mảng con thứ 2 có nhiều hơn 1 ptử thì sort mảng con này bằng thuật toán Quick Sort.



Trang 14



- Cài đặt thuật toán :
+ Pivot Mid:


+ Pivot Low (Vị trí đầu):




Trang 15




+ Pivot Random (Ngẫu nhiên):

Trang 16



- Phân tích độ phức tạp:
Với dữ liệu input như nhau ta có thể chia ra 2 TH:
++ TH tốt nhất (Pivot ở MID):
Ta có mảng a[0,1,…n-1], theo thuật toán ta sẽ có 2 mảng:
+ Mảng 1: có k phần tử (hay n/2).
+ Mảng 2: có n – k phần tử (hay n/2).
 T(n) = T(k) + T(n-k) + cn
Với :
+ T(k) là thời gian sắp xếp mảng k phần tử.
+ T(n-k) là thời gian sắp xếp mảng với n – k phần tử.
+ cn là tổng thời gian sắp xếp lại mảng a.
 Giống như Merge Sort ta kết luận BigO : O(nlogn)
++ TH xấu nhất (Pivot ở Low or High):
Ta có mảng a[0,1,…n-1], theo thuật toán ta sẽ có 2 mảng:
+ Mảng 1: có 1 phần tử.
+ Mảng 2: có n – 1 phần tử.
 T(n) = T(n - 1) + T(1) + cn (1)
Giải hệ thức truy hồi ta có:
T(n-1) = T(n-2) + T(1) + c(n-1)
T(n-2) = T(n-3) + T(1) + c(n-2)
Ta có (1) <=>T(n) = (T(n-2) + T(1) + c(n-1)) + T(1) + cn = T(n-2) + 2T(1) + c((n - 1) + n)
= (T(n-3) + T(1) + c(n-2)) + 2T(1) + c((n - 1) + n)
= T(n - 3) + 3T(1) + c((n-2) + (n-1) + n)
….

= T(n - k) + kT(1) + c((n-k+1)+…. + (n-1) + n)



Trang 17



= T(n - k) + kT(1) + c(   


)
ĐK dừng khi T(n-k) = T(1) khi đó k = n – 1.
Thay vào ta đc.
T(n) = T(1) + (n-1)T(1) +c(

  


)
= nT(1) + B
B = (n-2)(n+1)/2
 BigO : O(n^2)
- Ưu – nhược điểm:
Ưu điểm
Nhươc điểm
Là thuật toán chạy nhanh nhất ở TH trung
bình
Trường hợp xấu nhất có thời gian O(n^2)
Không cần bộ nhớ phụ

Không ổn định
Xài tốt cho danh sách liên kết


6. Heap sort :
- Khái niệm :
Thuật toán Heap sort hay còn gọi là thuật toán vun đống, đây là một thuật toán kinh điển với
độ phức tạp cao hơn Bubble sort nhưng hiệu quả cao hơn.
Thuật toán Heap sort sử dụng cây nhị phân để giải thuật. Cây nhị phân này hoạt động theo
nguyên tắc, phần tử trên cùng luôn là lớn nhất.

Hình 6 : Heap biểu diễn bằng mảng.



Trang 18



- Ý tưởng thuật toán :
B1: Xây dựng Heap :
=> Sử dụng thao tác Heapify để chuyển đổi mảng bình thường thành Heap.
* Heapify :

*Build heap :
– Tất cả các phần tử trên mảng có chỉ số [n/2] đến [n – 1] đều là node lá.
– Mỗi node lá được xem là Heap có duy nhất 1 phần tử.
– Thực hiện thao tác Heapify trên các phần tử có chỉ số từ [n/2 – 1] => 0 ta sẽ tạo được 1
Heap có n phần tử.

Trang 19



B2: Sắp xếp :
+ Hoán vị phần tử cuối cùng của Heap với phần tử đầu tiên của Heap.
+ Loại bỏ phần tử cuối cùng.
+ Thực hiện thao tác Heapify để điều chỉnh phần tử đầu tiên.

- Ưu – nhược điểm :
Ưu điểm
Nhươc điểm
Trong trường hợp xấu nhất tốt hơn Quick
sort
Chậm hơn Quick – Merge sort
Khong dùng đệ quy

Mảng được sắp xếp 1 phần thì nhanh hơn
Quick sort



7. Radix sort:
- Khái niệm:
Radix Sort là một thuật toán sắp xếp tiếp cận theo một hướng hoàn toàn khác so với các
thuật toán khác. Nếu như trong các thuật toán khác, cơ sở để sắp xếp luôn là việc so sánh giá
trị của 2 phần tử thì Radix sort lại dựa trên nguyên tắc phân loại thư của bưu điện. Nó không

Trang 20



hề quan tâm đến việc so sánh giá trị của phần tử và bản thân việc phân loại và trình tự phân
loại sẽ tạo ra thứ tự cho các phần tử.
Ta biết rằng, để chuyển một 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 một hệ thống phân loại thư phân cấp. Trước tiên, các thư
đến cùng một tỉnh, thành phố sẽ được sắp chung vào một lô để gửi đến tỉnh thành tương ứng.
Bưu điện các tỉnh thành này lại thực hiện công việc tương tự. Các thư đến cùng một quận,
huyện sẽ được xếp vào chung một lô và gửi đến quận, huyện tương ứng. 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 nhọc.
- Ý tưởng và thuật toán:
Giả sử ta có mỗi phần tử trong mảng a[0,1,…n-1] là một số nguyên có m chữ số. Ta phân
loại lần lược các chữ số theo hang đơn vị, hàng chục, hàng trăm,… tương tự như việc phân
loại theo tỉnh, huyện, phường, xã…
Các bước cài đặt:
Bước 1:
// k cho biết chữ số dùng để phân loại hiện hành
k = 0; // k = 0: hàng đơn vị; k = 1:hàng chục;
Bước 2:
//Tạo các lô chứa các loại phần tử khác nhau
Khởi tạo n lô B0, B1, ., Bn-1 rỗng;
Bước 3:
For i = 1…n do
Ðặt ai vào lô Bt với t = chữ số thứ k của ai;

Bước 4:
Nối B0, B1,… Bn-1 lại (theo đúng trình tự) thành a.
Bước 5:
k = k+1;
Nếu k < m thì trở lại bước 2.



Trang 21



Ngược lại: Dừng.
Ví dụ:
Ta có mảng B gồm các phẩn tử như sau:
7013
8421
1239
428
1424
7009
4518
3252
9170
999
1725
701
Trong Radix Sort sẽ có một điều không thuận tiện là danh sách các số nguyên vì trong danh
sách ấy có thể có các số nguyên có chiều dài không bằng nhau.
Để khắc phục điều này ta thêm chữ số 0 vào phía trước các chữ số ngắn để được mảng các

phần tử có chùng chiều dài bằng nhau là 4.
Mảng B sau khi thêm các chữ số 0.
7013
8421
1239
0428
1424
7009
4518
3252
9170
0999
1725
0701

Phân lô theo hàng đơn vị:









0999

1725


4518
7009
9170
0701
3252
7013
1424
8425


0428
1239
0
1
2
3
4
5
6
7
8
9
Ta được mảng B như sau:
9170
0701
3252

7013
1424
8425
1725
0428
4518
1239
7009
0999

Phân lô theo hàng chục:


0428









1725

7009
4518
8425







0701
7013
1424
1239

3252

9170

0999
0
1
2
3
4
5
6
7
8

9
Ta được mảng B như sau:
0701
7009
7013
4518
1424
8425
1725
0428
1239
3252
9170
0999

Phân lô theo hàng trăm:




0428





7013

3252

8425


1725


7009
9170
1239

1424
4518

0701

0999
0
1
2
3
4
5
6
7
8
9
Ta được mảng B như sau:

Trang 22



7009
7013
9170
1239
3252
1424
8425
0428
4518
0701
1725
0999

Phân lô theo hàng nghìn:
0999
1725








0701
1424

7013


0428
1239

3252
4518


7009
8425
9170
0
1
2
3
4
5
6
7
8
9
Ta được mảng B đã sắp xếp hoàn thành như sau:
0428

0701
0999
1239
1424
1725
3252
4518
7009
7013
8425
9170

- Nhận xét:
Giải thuật Radix Sort không dựa trên sự so sánh dữ liệu như các giải thuật sắp xếp khác.
Với mỗi số nguyên từ dữ liệu sẽ có hai hành động được thực thi.
+ Thực hiện phép chia lấy nguyên cho 1 hệ số để lấy phần chữ số d và các chữ số trước nó
(bỏ các chữ số sau nó).
+ Thực hiện phép chia lấy dư cho 10 để lấy ra chữ số d (bỏ các chữ số trước d).
- Cài đặt thuật toán:

- Phân tích độ phức tạp:



Trang 23



Với một dãy n số, mỗi số có tối đa m chữ số, thuật toán thực hiện m lần các thao tác phân
lô và ghép lô. Trong thao tác phân lô, mỗi phần tử chỉ được xét đúng một lần, khi ghép cũng

vậy.
Sau lần phân phối thứ k các phần tử của A vào các lô B0, B1, ., Bn-1, và lấy ngược trở ra,
nếu chỉ xét đến k+1 chữ số của các phần tử trong B, ta sẽ có một mảng tăng dần nhờ trình tự
lấy ra từ 0 -> n-1. Nhận xét này bảo đảm tính đúng đắn của thuật toán
Thuật toán có độ phức tạp tuyến tính nên hiệu quả khi sắp dãy có rất nhiều phần tử, nhất là
khi khóa sắp xếp không quá dài so với số lượng phần tử (điều này thường gặp trong thực tế).
 BigO : O(kn).
II. Môi trường thực nghiệm:
1. Cấu hình máy thực nghiệm:


2. Cấu trúc dữ liệu thực nghiệm: Mảng (Array[])
3. Kiểu dữ liệu thực nghiệm: Integer.
Với 3 dạng case ứng với các trường hợp Tốt nhất, Trung bình, Xấu nhất.



Trang 24



- Best case: Dữ liệu sau khi random sẽ được sort trước 1 lần giống với yêu cầu cần sắp xếp.
VD: yêu cầu sắp xếp tăng thì input với dữ liệu Best case sẽ đc sắp xếp tăng và ngược lại.

- Average case: Dữ liệu được tạo ngẫu nhiên.

- Worst case: Ngược lại với Best case.

Trang 25




4. Hàm tính thời gian trong c#:

III. Thực nghiệm:
1. Insertion sort:
- Best case:
+ Ta có 100000 số kiểu integer bắt đầu từ 0 -> 999999 đã sắp xếp (best).