NIÊN LUẬN CƠ SỞ NGÀNH KỸ THUẬT PHẦN MỀM

PHẦN MỀM MÔ PHỎNG CÁC THUẬT TOÁN SẮP XẾP

Sinh viên thực hiện Cán bộ hướng dẫn

Nguyễn Văn Tài ThS.GVC. Võ Huỳnh Trâm

MSSV: B1400722

HỌC KỲ 1, 2017 - 2018

TRƯỜNG ĐẠI HỌC CẦN THƠ

KHOA CÔNG NGHỆ THÔNG TIN & TRUYỀN THÔNG

BỘ MÔN CÔNG NGHỆ PHẦN MỀM

ĐÁNH GIÁ KẾT QUẢ THỰC HIỆN NIÊN LUẬN CƠ SỞ NGÀNH KTPM

(Học kỳ 1, Năm học 2017-2018)

GIÁO VIÊN HƯỚNG DẪN:

STT HỌ VÀ TÊN MSCB

1 Võ Huỳnh Trâm

SINH VIÊN THỰC HIỆN:

STT HỌ VÀ TÊN MSSV THƯỞNG

(Tối đa 1,0 điểm) ĐIỂM

1 Nguyễn Văn Tài B1400722

I. HÌNH THỨC (Tối đa 0,5 điểm)

Bìa (tối đa 0,25 điểm)

Các tiêu đề: Trường ĐHCT, Khoa CNTT

Loại niên luận: Cơ sở ngành KTPM, Tên đề tài

Giáo viên hướng dẫn: chức danh, họ tên.

Thông tin về các sinh viên thực hiện: họ tên, mã số, lớp

Năm thực hiện

Bố cục (tối đa 0.25 điểm)

Nhận xét của giáo viên hướng dẫn và giáo viên chấm

Mục lục: cấu trúc chương, mục và tiểu mục

Phụ lục (nếu có)

Tài liệu tham khảo

II. NỘI DUNG (Tối đa 3,5 điểm)

Tổng quan (tối đa 0,5 điểm)

Mô tả bài toán, mục tiêu cần đạt được (0,25 điểm)

Hướng giải quyết và kế hoạch thực hiện (0,25 điểm)

Lý thuyết (tối đa 0,5 điểm)

Các khái niệm sử dụng trong đề tài

Kết quả vận dụng lý thuyết vào đề tài

Ứng dụng (tối đa 2,0 điểm)

Phân tích yêu cầu bài toán, xây dựng các cấu trúc dữ liệu cần thiết (tối đa

0,5 điểm)

Giải thuật (Lưu đồ-Ngôn ngữ giả) (1,0 điểm)

Giới thiệu chương trình (0,5 điểm)

Kết luận (tối đa 0,5 điểm)

Nhận xét kết quả đạt được

Hạn chế

Hướng phát triển

III. CHƯƠNG TRÌNH DEMO (Tối đa 5,0 điểm)

Giao diện thân thiện với người dùng (1.0 điểm)

Hướng dẫn sử dụng (0,5 điểm)

Kết quả thực hiện đúng với kết quả của phần ứng dụng (3,5 điểm)

Ghi chú: Điểm trong khung “các sinh viên thực hiện” là điểm kết quả cuối cùng của từng sinh viên trong quá trình

thực hiện niên luận 1.

Nếu sinh viên demo chương trình và trả lời vấn đáp không đạt yêu cầu của giáo viên hướng dẫn thì sinh

viên sẽ nhận điểm F cho học phần này. Cần Thơ, ngày tháng năm 2017

GIÁO VIÊN CHẤM

MỤC LỤC Chương 1. Tổng quan...................................................................................................1

I. Mô tả bài toán .....................................................................................................1

II. Mục tiêu cần đạt được ........................................................................................1

III. Hướng giải quyết ................................................................................................1

IV. Kế hoạch thực hiện .............................................................................................2

Chương 2. Lý thuyết ....................................................................................................2

I. Các khái niệm .....................................................................................................2

2.1.1. Khái niệm sắp xếp và thuật toán sắp xếp ......................................................2

2.1.2. Khái niệm các thuật toán sắp xếp .................................................................3

II. Kết quả vận dụng lý thuyết vào đề tài .................................................................3

Chương 3. Kết quả ứng dụng.......................................................................................4

I. Phân tích yêu cầu bài toán ..................................................................................4

II. Xây dựng các cấu trúc dữ liệu cần thiết ..............................................................5

3.2.1 Hàm tạo mảng ..............................................................................................5

3.2.2 Hàm đặt mảng về 0 ......................................................................................5

3.2.3 Hàm xoá mảng .............................................................................................6

3.2.4 Hàm tạo dữ liệu mảng ngẫu nhiên ................................................................6

3.2.5 Hàm nhập dữ liệu mảng bằng tay trong FormInput.java ...............................6

3.2.6 Hàm ghi tập tin văn bản lúc mở phần mềm ..................................................7

3.2.7 Mở và đọc tập tin văn bản ............................................................................7

3.2.8 Hàm tô sáng dòng code trong lúc thuật toán đang chạy ................................9

3.2.9 Hàm kiểm tra dãy đã sắp xếp xong hay chưa ................................................9

3.2.10 Hoán đổi vị trí trên khung chạy mô phỏng ...................................................9

3.2.11 Hàm đặt lại vị trí của các số trên khung chạy mô phỏng ............................. 10

3.2.12 Hàm chờ đợi để dừng thuật toán ................................................................ 10

3.2.13 Hàm dừng quá trình sắp xếp ....................................................................... 11

3.2.14 Thuật toán sắp xếp chọn ............................................................................. 11

3.2.15 Thuật toán sắp xếp nổi bọt ......................................................................... 12

3.2.16 Thuật toán sắp xếp xen ............................................................................... 13

3.2.17 Thuật toán sắp xếp vun đống ...................................................................... 14

3.2.18 Thuật toán sắp xếp nhanh ........................................................................... 15

3.2.19 Thuật toán sắp xếp trộn .............................................................................. 15

III. Thiết kế giải thuật (Lưu đồ - Ngôn ngữ giả)...................................................... 16

IV. Giới thiệu chương trình .................................................................................... 17

3.4.1 Giao diện chính .......................................................................................... 17

3.4.2 Giao diện hướng dẫn sử dụng ..................................................................... 18

3.4.3 Giao diện thông tin phần mềm ................................................................... 19

3.4.4 Giao diện nhập dữ liệu mảng bằng tay ....................................................... 20

Chương 4. Kết luận – đánh giá .................................................................................. 20

I. Kết quả đạt được .............................................................................................. 20

4.1.1 Về mặt chuyên môn ................................................................................... 20

4.1.2 Về mặt kinh nghiệm ................................................................................... 20

II. Hạn chế và nguyên nhân ................................................................................... 21

III. Hướng phát triển............................................................................................... 21

Phụ Lục ........................................................................................................................ 22

Chương 1. Hướng dẫn sử dụng phần mềm ............................................................... 22

Chương 2. Tài liệu tham khảo ................................................................................... 24

1

CHƯƠNG 1. TỔNG QUAN

I. MÔ TẢ BÀI TOÁN

Hiện nay, trong hầu hết các hệ thống lưu trữ, quản lý dữ liệu, thao tác tìm kiếm

thường được thực hiện nhiều nhất để khai thác thông tin một cách nhanh chóng (ví dụ như:

tra cứu từ điển, tìm sách trong thư viện,...). Tuy nhiên, để cho việc tìm kiếm đó được diễn

ra nhanh chóng, chính xác thì dữ liệu cần được sắp xếp sẵn gọn gàng, ngăn nắp theo một

trật tự nhất định. Khi đó, việc tìm kiếm, truy xuất dữ liệu trở nên dễ dàng hơn. Điều này

có ý nghĩa rất lớn trong việc quản lý và lưu trữ dữ liệu.

Tuy biết rằng chỉ cần dữ liệu được sắp xếp ngăn nắp thì sẽ dễ dàng sử dụng, nhưng

trong thực tế, chúng ta còn gặp phải một rắc rối rất lớn đó là thế giới đã cho ra đời quá

nhiều cách sắp xếp khác nhau, mà mỗi cách sắp xếp lại có ưu, nhược điểm riêng. Thế thì

lựa chọn cách nào là phù hợp nhất với nhu cầu của người sử dụng?

Nắm bắt được nhu cầu đó, phần mềm “Mô phỏng các thuật toán sắp xếp” đã ra đời.

Phần mềm này giúp người sử dụng có thể nhìn thấy được cách thức hoạt động của các

thuật toán theo từng bước một cách dễ hiểu nhất. Qua đó, phần mềm giúp ta có thể hiểu rõ

hơn về mỗi dòng code trong cấu trúc dữ liệu tương ứng sẽ làm việc như thế nào.

Phần mềm sử dụng các hình ảnh đồ hoạ trực quan, sinh động nhằm biểu diễn cách

thức hoạt động của các thuật toán một cách dễ hiểu mà vẫn không mất nhiều thời gian để

cố gắng đọc hiểu code. Từ tất cả những lợi ích trên, phần mềm “Mô phỏng các thuật toán

sắp xếp” giúp đỡ cho việc học tập các cấu trúc dữ liệu và giải thuật, phân tích và thiết kế

thuật toán của sinh viên trở nên dễ dàng, hiệu quả, thú vị và tính ứng dụng thực tế cao hơn

rất nhiều so với các dòng code khô khan.

II. MỤC TIÊU CẦN ĐẠT ĐƯỢC

- Nắm vững kiến thức cấu trúc dữ liệu và giải thuật, phân tích và thiết kế thuật toán

về các thuật toán sắp xếp được cài đặt trong phần mềm.

- Thể hiện việc sắp xếp của thuật toán một cách cụ thể bằng giao diện đồ hoạ.

- Thể hiện được việc sắp xếp của từng dòng code trên thực tế diễn ra như thế nào.

- Học cách sử dụng Thread, cách tạo chuyển động trên form.

- Thiết kế được logo riêng cho phần mềm.

- Biết cách đóng gói phần mềm và ghi ra đĩa.

III. HƯỚNG GIẢI QUYẾT

Trước tiên, cần phải tìm hiểu lại thật kỹ các thuật toán sắp xếp đã được học trong

các môn trước đó. Chọn lọc ra 6 thuật toán tiêu biểu và chia ra làm 2 nhóm. Nhóm 1 gồm

các thuật toán sắp xếp đơn giản: Sắp xếp chọn (Selection Sort), Sắp xếp nổi bọt (Bubble

Sort) và Sắp xếp xen (Insertion Sort). Nhóm 2 gồm các thuật toán sắp xếp phức tạp: Sắp

xếp vun đống (Heap Sort), Sắp xếp nhanh (Quick Sort) và Sắp xếp trộn (Merge Sort).

2

Sau khi đã có được 2 nhóm thuật toán, tiến hành tạo mảng các con số để sắp xếp.

Mảng này có thể được tạo bằng 3 cách: tạo ngẫu nhiên (tạo ra một mảng với các phần tử

có giá trị bất kỳ), nhập bằng tay (cho phép người dùng nhập số lượng phần tử của mảng

và giá trị lần lượt của từng phần tử trong mảng), nhập từ tập tin (cho phép người dùng

nhập vào các giá trị của các phần tử trong mảng thông qua một tập tin văn bản được tạo ra

trong lúc mở phần mềm). Bên cạnh đó, cần có thêm chức năng đặt giá trị của tất cả các

phần tử về 0 trong trường hợp người dùng muốn khởi tạo lại mảng khác.

Tiếp theo, sẽ cho phép người dùng lựa chọn các thuật toán sắp xếp. Trong lúc người

dùng đang chọn thuật toán, cần phải có khung code để hiển thị nội dung của thuật toán đó.

Người dùng có thể tuỳ chỉnh độ to, nhỏ của code. Các thuật toán sẽ được đưa vào 2 nhóm

riêng biệt là đơn giản và phức tạp. Chỉ cho phép người dùng chọn một thuật toán để tiến

hành mô phỏng bằng cách đưa tên cách thuật toán vào một nhóm các radio button.

Cuối cùng là cho phép người dùng chọn thứ tự sắp xếp: tăng dần, giảm dần và tiến

hành sắp xếp. Bên cạnh đó, cần có một thanh trượt để cho phép người dùng điều chỉnh

được tốc độ chạy của thuật toán.

IV. KẾ HOẠCH THỰC HIỆN

Tuần Công việc

Tuần 1 – Tuần 2 Tìm hiểu và chọn lọc các giải thuật sắp xếp.

Tuần 3 – Tuần 4 Vẽ lưu đồ của phần mềm bằng ngôn ngữ giả.

Tuần 5 Thiết kế giao diện và logo.

Tuần 6 Gửi giao diện cho người dùng cụ thể xem và đánh giá để chỉnh sửa

lại giao diện theo cảm quang của người dùng.

Tuần 7 – Tuần 11 Code chức năng, giải thuật và giao diện đồ hoạ cho giải thuật.

Tuần 12 Kiểm thử phần mềm.

Tạo tài liệu hướng dẫn sử dụng phần mềm.

Tuần 13 Đóng gói phần mềm và viết báo cáo.

CHƯƠNG 2. LÝ THUYẾT

I. CÁC KHÁI NIỆM

2.1.1. Khái niệm sắp xếp và thuật toán sắp xếp

Sắp xếp là quá trình bố trí lại các phần tử trong một tập hợp theo một trình tự nào đó

nhằm mục đích giúp quản lý và tìm kiếm các phần tử dễ dàng và nhanh chóng hơn.

3

Thuật toán sắp xếp là một thuật toán sắp xếp các phần tử của một danh sách (hoặc

một mảng) theo thứ tự (tăng hoặc giảm). Và để dễ dàng cho việc nghiên cứu và học tập thì

người ta thường gán các phần tử được sắp xếp là các chữ số.

2.1.2. Khái niệm các thuật toán sắp xếp

Sắp xếp chọn (Selection Sort): là phương pháp sắp xếp chọn phần tử nhỏ nhất hoặc

lớn nhất trong N phần tử của dãy hiện hành. Đưa phần tử này về vị trí đầu dãy hiện hành.

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 cho đến khi dãy hiện hành chỉ còn 1 phần tử.

Sắp xếp nổi bọt (Bubble Sort): là phương pháp sắp xếp xuất phát từ cuối dãy, đổi

chỗ các cặp phần tử kế cận để đưa phần tử nhỏ hơn hoặc lớn hơn trong cặp phần tử đó về

vị trí đứng đầu dãy hiện hành, sau đó sẽ không xét đến nó ở bước tiếp theo. Lặp lại xử lý

trên cho đến khi không còn cặp phần tử nào để xét.

Sắp xếp xen (Insertion Sort): là phương pháp sắp xếp chèn phần tử đang xét vào vị

trí thích hợp của đoạn đã được sắp để có dãy mới trở nên có thứ tự. Lặp lại quá trình trên

cho đến khi dãy được sắp xếp xong.

Sắp xếp vun đống (Heap Sort): là một trong các phương pháp sắp xếp chọn. Ở mỗi

bước của sắp xếp chọn ta chọn phần tử lớn nhất (hoặc nhỏ nhất) đặt vào cuối (hoặc đầu)

danh sách, sau đó tiếp tục với phần còn lại của danh sách. Sắp xếp vun đống chọn ra được

một cấu trúc dữ liệu cho phép tích lũy các thông tin về sự so sánh giá trị các phần tử trong

quá trình sắp xếp.

Sắp xếp nhanh (Quick Sort): là phương pháp sắp xếp theo tư tưởng chia để trị, nó

dựa trên thủ tục phân chia như sau: để chia một dãy ta chọn một phần tử được gọi là "chốt"

(pivot), chuyển tất cả các phần tử nhỏ hơn chốt về trước chốt, chuyển tất cả các phần tử

lớn hơn (hoặc nhỏ hơn) chốt về sau (hoặc trước) nó. Tiếp tục phân chia các dãy con đó

như trên cho đến khi các dãy con chỉ còn một phần tử.

Sắp xếp trộn (Merge Sort): là phương pháp sắp xếp theo tư tưởng chia để trị. Thủ

tục cơ bản là việc trộn hai danh sách đã được sắp xếp vào một danh sách mới theo thứ tự.

Nó có thể bắt đầu trộn bằng cách so sánh hai phần tử một (chẳng hạn phần tử thứ nhất với

phần tử thứ hai, sau đó thứ ba với thứ tư,...). Sau khi kết thúc bước 1 nó chuyển sang bước

2. Ở bước 2 nó trộn các danh sách hai phần tử thành các danh sách bốn phần tử. Cứ như

vậy cho đến khi hai danh sách cuối cùng được trộn thành một.

II. KẾT QUẢ VẬN DỤNG LÝ THUYẾT VÀO ĐỀ TÀI

Áp dụng các thuật toán sắp xếp để đưa vào phần mềm có giao diện đồ hoạ trực quan,

sinh động; Áp dụng Thread để có thể nhìn thấy các phần tử di chuyển mượt mà khi sắp

xếp, giúp người dùng kịp nhận ra sự thay đổi vị trí của các phần tử; Bắt sự kiện kéo thanh

trượt để thay đổi tốc độ sắp xếp và độ to nhỏ của code.

4

CHƯƠNG 3. KẾT QUẢ ỨNG DỤNG

I. PHÂN TÍCH YÊU CẦU BÀI TOÁN

Phần mềm “Mô phỏng các thuật toán sắp xếp” đặt ra yêu cầu chủ yếu và trọng tâm

là phải minh hoạ được trực quan bằng giao diện đồ hoạ cách thức hoạt động của các thuật

toán sắp xếp.

Dữ liệu đầu vào của phần mềm sẽ là một mảng các con số có giá trị ngẫu nhiên, nhập

bằng tay hoặc nhập từ tập tin văn bản tuỳ vào cách tạo dữ liệu mảng của người dùng. Cụ

thể, người dùng sẽ được nhập số lượng phần tử để tạo ra một mảng (số lượng phần tử sẽ

từ 2 đến 15 phần tử). Sau đó, người dùng sẽ lựa chọn một trong ba cách tạo dữ liệu mảng,

bao gồm: tạo ngẫu nhiên, nhập bằng tay và nhập từ tập tin văn bản.

Tạo ngẫu nhiên: Ở cách này, người dùng chỉ cần click chọn nút “Tạo ngẫu nhiên”,

phần mềm sẽ chọn một cách ngẫu nhiên giá trị cho các phần tử trong mảng tương ứng với

số lượng phần tử mà người dùng đã chọn trước đó. Để thực hiện việc này, ta cần thiết kế

một hàm có tên createRandom(). Hàm này có tác dụng tạo ra một giá trị ngẫu nhiên

rồi truyền vào từng giá trị của các phần tử trong mảng bằng một vòng lặp.

Nhập bằng tay: Với cách này, ta cần tạo thêm một Form mới được gọi bởi nút “Bằng

tay” cho phép người dùng nhập số lượng phần tử và giá trị từng phần tử vào. Sau khi có

số lượng phần tử mà người dùng nhập vào, ta cần có một vòng lặp để in tất cả các phần tử

và ô nhập giá trị các phần tử lên Form để người dùng có thể nhập tuần tự giá trị của các

phần tử. Vì số lượng phần tử tối thiểu là 2 và tối đa là 15, nên ta cần thiết kế vị trí hiển thị

ô nhập giá trị phần tử theo 3 cột để người dùng dễ dàng sử dụng.

Nhập từ tập tin văn bản: Cách này sẽ giúp người dùng nhập được nhanh hơn giá trị

của các phần tử thông qua một tập tin văn bản. Với cách này, người dùng sẽ tiết kiệm được

nhiều thao tác chuột hơn, từ đó giúp cho việc sử dụng phần mềm nhanh hơn, hiệu quả hơn.

Để bắt đầu được việc sử dụng tập tin, ta cần phải tạo ra một hàm ghiMang() có tác dụng

khởi tạo ra một tập tin array.txt chứa đoạn văn bản mẫu. Tập tin này sẽ xuất hiện cạnh

phần mềm đã được đóng gói trong quá trình người dùng mở phần mềm. Khi người dùng

click chọn nút “Mở file”, phần mềm sẽ dùng thư viện Desktop của Java để gọi đến

hàm open. Khi đó, hệ điều hành sẽ tự động mở tập tin array.txt và người dùng chỉ

cần chỉnh sửa lại nội dung của tập tin phù hợp với nhu cầu của mình. Kế tiếp, người dùng

cần click vào nút “Đọc file”, phần mềm sẽ tiến hành đọc nội dung của tập tin nói trên và

truyền dữ liệu vào mảng đã được tạo.

Phần mềm cần cho phép người dùng lựa chọn được thuật toán để xem mô phỏng, lựa

chọn thứ tự sắp xếp tăng dần hay giảm dần, điều chỉnh tốc độ của khung chạy mô phỏng,

điều chỉnh độ to nhỏ của khung code xem trước và dừng thuật toán bất cứ khi nào.

Dữ liệu đầu ra của phần mềm là dãy số đã được sắp xếp theo thứ tự (tăng dần hoặc

giảm dần) cùng với một thông báo đã sắp xếp xong để người dùng có thể kiểm tra lại dãy

số bằng tay.

5

II. XÂY DỰNG CÁC CẤU TRÚC DỮ LIỆU CẦN THIẾT

Để thực hiện được việc sắp xếp, ta cần xây dựng các cấu trúc dữ liệu, các thuật toán

sắp xếp được cài đặt theo khung chạy mô phỏng, các hàm cần thiết như sau:

3.2.1 Hàm tạo mảng

public void createArrays() { //delete previous arrays and set number elements of array deleteArrays(); num = (Integer)spNum.getValue(); lbArrays = new JLabel[num]; array = new int[num]; for (int i = 0; i < num; i++) { //create label, set text "0" lbArrays[i] = new JLabel("0"); array[i] = 0; pnKhungMoPhong.add(lbArrays[i]); lbArrays[i].setText(String.valueOf(array[i])); //set size label lbArrays[i].setSize(50,50); lbArrays[i].setOpaque(true); lbArrays[i].setForeground(Color.blue); //set location label if (i == 0) lbArrays[i].setLocation(((int) ((18 - num) * 0.5) * 70) + 100, 150); else lbArrays[i].setLocation(lbArrays[i-1].getX() + 70, 150); //set fonts lbArrays[i].setFont(new Font("Tahoma", Font.PLAIN, 30)); //set background color lbArrays[i].setBackground(SystemColor.inactiveCaption); //set text alignment center lbArrays[i].setHorizontalAlignment(SwingConstants.CENTER); lbArrays[i].setVerticalAlignment(SwingConstants.CENTER); } pnKhungMoPhong.add(lbPoint1); pnKhungMoPhong.add(lbPoint2); pnKhungMoPhong.add(lbPointM); pnKhungMoPhong.setVisible(true); pnKhungMoPhong.validate(); pnKhungMoPhong.repaint(); setState(1); }

3.2.2 Hàm đặt mảng về 0

public void setZero() { for (int i = 0; i < num; i++) { lbArrays[i].setText("0"); array[i] = 0; } createArrays(); pnKhungMoPhong.revalidate(); pnKhungMoPhong.repaint(); setState(1); }

6

3.2.3 Hàm xoá mảng

public void deleteArrays() { for (int i = 0; i < num; i++) { lbArrays[i].setText("0"); array[i] = 0; lbArrays[i].setVisible(false); pnKhungMoPhong.remove(lbArrays[i]); } lbPoint1.setText(""); lbPoint2.setText(""); lbPointM.setText(""); pnKhungMoPhong.remove(lbPoint1); pnKhungMoPhong.remove(lbPoint2); pnKhungMoPhong.remove(lbPointM); for (int i = 0; i < curT; i++) { try { threads[i].interrupt(); }catch (Exception e) {} } curT = -1;

pnKhungMoPhong.revalidate(); pnKhungMoPhong.repaint(); setState(0); }

3.2.4 Hàm tạo dữ liệu mảng ngẫu nhiên

public void createRandom() { Random rand = new Random(); for (int i = 0; i < num; i++) { int ranNum = rand.nextInt(101) + 0; lbArrays[i].setText(String.valueOf(ranNum)); lbArrays[i].setForeground(Color.BLUE); array[i] = ranNum; } pnKhungMoPhong.setVisible(true); pnKhungMoPhong.validate(); pnKhungMoPhong.repaint(); setState(2); }

3.2.5 Hàm nhập dữ liệu mảng bằng tay trong FormInput.java

public void createArray() { deleteArrays(); num = (Integer)spNum.getValue(); arrays = new int[num]; lbArrays = new JLabel[num]; txtArrays = new JSpinner[num]; arrays = new int[num]; for (int i = 0; i < num; i++) { lbArrays[i] = new JLabel("A[" + i + "]:"); SpinnerModel smValue = new SpinnerNumberModel(0, 0, 100, 1); txtArrays[i] = new JSpinner(smValue); JFormattedTextField txt = ((JSpinner.NumberEditor) txtArrays[i].getEditor()).getTextField();

7

((NumberFormatter) txt.getFormatter()).setAllowsInvalid(false); contentPane.add(lbArrays[i]); contentPane.add(txtArrays[i]); lbArrays[i].setSize(40,30); if (i == 0 || i == 5 || i == 10) lbArrays[i].setLocation(150 * (i + 1)/5 , 40); else lbArrays[i].setLocation(lbArrays[i-1].getX(), lbArrays[i-1].getY() + 40); txtArrays[i].setSize(50,30); txtArrays[i].setLocation(lbArrays[i].getX() + 40, lbArrays[i].getY()); } contentPane.setVisible(true); contentPane.validate(); contentPane.repaint(); }

3.2.6 Hàm ghi tập tin văn bản lúc mở phần mềm

public void ghiMang(){ BufferedWriter out = null; try { out = new BufferedWriter(new FileWriter("array.txt")); out.write("8\n" + "1\n" + "2\n" + "3\n" + "4\n" + "5\n" + "1\n" + "5\n" + "8\n"); } catch (IOException e){} finally { try { out.close(); } catch (IOException ex) { Logger.getLogger(FormMain.class.getName()).log(Level.SEVERE, null, ex); } } }

3.2.7 Mở và đọc tập tin văn bản

btnOpenFile = new JButton("Mở file"); btnOpenFile.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { try { Desktop desktop = null; if (Desktop.isDesktopSupported()) { desktop = Desktop.getDesktop(); } desktop.open(file); } catch (IOException ioe) { //file isn't existed ioe.printStackTrace(); } } }); btnReadFile = new JButton("Đọc file"); btnReadFile.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent arg0) {

8

deleteArrays(); try { Scanner in = new Scanner(file); num = Integer.parseInt(in.nextLine()); array = new int[num]; int pos = 0; while (in.hasNextLine()) { array[pos] = Integer.parseInt(in.nextLine()); pos++; } in.close(); lbArrays = new JLabel[num]; for (int i = 0; i < num; i++) { //create label, set text "0" lbArrays[i] = new JLabel(String.valueOf(array[i])); pnKhungMoPhong.add(lbArrays[i]); //set size label lbArrays[i].setSize(50,50); lbArrays[i].setOpaque(true); lbArrays[i].setForeground(Color.BLUE); //set location label if (i == 0) lbArrays[i].setLocation(((int) ((18 - num) * 0.5) * 70) + 100, 150); else lbArrays[i].setLocation(lbArrays[i-1].getX() + 70, 150); //set fonts lbArrays[i].setFont(new Font("Tahoma", Font.PLAIN, 30)); //set background color lbArrays[i].setBackground(SystemColor.inactiveCaption); //set text alignment center lbArrays[i].setHorizontalAlignment(SwingConstants.CENTER); lbArrays[i].setVerticalAlignment(SwingConstants.CENTER); } pnKhungMoPhong.setVisible(true); pnKhungMoPhong.validate(); pnKhungMoPhong.repaint(); setState(2); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } });

9

Hàm tô sáng dòng code trong lúc thuật toán đang chạy

3.2.8 Hàm kiểm tra dãy đã sắp xếp xong hay chưa

public boolean isSorted() { if (isIncrease) { for (int i = 0; i < array.length - 1; i++) if (array[i] > array[i+1]) return false; } else { for (int i = 0; i < array.length - 1; i++) if (array[i] < array[i+1]) return false; } return true; }

3.2.9 Hoán đổi vị trí trên khung chạy mô phỏng

public void Swap(JLabel lb1, JLabel lb2) { int x1 = lb1.getX(); int x2 = lb2.getX(); curT ++; int cur = curT; threads[cur] = new Thread(new Runnable() { @Override public void run() { try { if (cur != 0) { threads[cur-1].join();} lb1.setBackground(processingColor); lb2.setBackground(processingColor); while (lb1.getY() > 100) { lb1.setLocation(lb1.getX(), lb1.getY() - 10); lb2.setLocation(lb2.getX(), lb2.getY() + 10); lbPointM.setLocation(x2, lbPointM.getY() + 10); Thread.sleep(time); } while (lb1.getX() < x2) { lb1.setLocation(lb1.getX() + 10, lb1.getY());

public void highLight(int line) { curT++; int cur = curT; threads[cur] = new Thread(new Runnable() { @Override public void run() { try { if (cur != 0) { threads[cur-1].join(); } lsCode.setSelectedIndex(line); lsCode.ensureIndexIsVisible(line); // Tu cuon den dong dang highlight Thread.sleep(time); } catch (Exception e) {} } }); threads[cur].start(); }

10

lb2.setLocation(lb2.getX() - 10, lb2.getY()); lbPointM.setLocation(lb2.getX(), 250); Thread.sleep(time); } while (lb1.getY() < 140) { lb1.setLocation(lb1.getX(), lb1.getY() + 10); lb2.setLocation(lb2.getX(), lb2.getY() - 10); lbPointM.setLocation(x1, lbPointM.getY() - 10); Thread.sleep(time); } String txtLb1 = lb1.getText(); lb1.setText(lb2.getText()); lb2.setText(txtLb1); lb1.setLocation(x1, 150); lb2.setLocation(x2, 150); lb1.setBackground(SystemColor.inactiveCaption); lb2.setBackground(SystemColor.inactiveCaption); } catch (Exception e) {} } }); threads[cur].start(); }

3.2.10 Hàm đặt lại vị trí của các số trên khung chạy mô phỏng

public void threadReLocate() { curT++; int cur = curT; threads[cur] = new Thread(new Runnable() { @Override public void run() { try { if (cur != 0) { threads[cur-1].join();} reLocate(); } catch (Exception e) {} } }); threads[cur].start(); } public void reLocate() { for (int i = 0; i < num; i++) { //set location label if (i == 0) lbArrays[i].setLocation(((int) ((18 - num) * 0.5) * 70) + 100, 150); else lbArrays[i].setLocation(lbArrays[i-1].getX() + 70, 150); } }

3.2.11 Hàm chờ đợi để dừng thuật toán

public void waitEnd() { curT++; int cur = curT; threads[cur] = new Thread(new Runnable() { @Override public void run() { try {

11

if (cur != 0) { threads[cur-1].join(); } setState(4); for (int i = 0; i < num; i++) { lbArrays[i].setForeground(Color.darkGray); } lbPoint1.setText(""); lbPoint2.setText(""); lbPointM.setText(""); FormCompleteSorted form = new FormCompleteSorted(); form.setVisible(true); } catch (Exception e) {} } }); threads[cur].start(); }

3.2.12 Hàm dừng quá trình sắp xếp

public void stopAllThreads() { for (int i = 0; i < curT; i++) { try { threads[i].interrupt(); } catch (Exception e) {} } curT = -1; }

3.2.13 Thuật toán sắp xếp chọn

public void SelectionSort() { if (isIncrease) { highLight(1); int min,i,j; for (i = 0; i < num - 1; i++) { highLight(2); setlbPoint(lbPoint1, i, "i = "); min = i; setlbPoint(lbPointM, i, "min"); highLight(3); for(j = i + 1; j < num; j++) { highLight(4); highLight(5); setlbPoint(lbPoint2, j, "j = "); if (array[j] < array[min]) { highLight(6); min = j; setlbPoint(lbPointM, j, "min"); } } if (min > i) { int temp = array[min]; array[min] = array[i]; array[i] = temp; highLight(7); Swap(lbArrays[i], lbArrays[min]); } }

12

} else { highLight(1); int min,i,j; for (i = 0; i < num - 1; i++) { highLight(2); setlbPoint(lbPoint1, i, "i = "); min = i; setlbPoint(lbPointM, i, "max"); highLight(3); for(j = i + 1; j < num; j++) { highLight(4); highLight(5); setlbPoint(lbPoint2, j, "j = "); if (array[j] > array[min]) { highLight(6); min = j; setlbPoint(lbPointM, j, "max"); } } if (min > i) { int temp = array[min]; array[min] = array[i]; array[i] = temp; highLight(7); Swap(lbArrays[i], lbArrays[min]); } } } highLight(0); }

3.2.14 Thuật toán sắp xếp nổi bọt

public void BubbleSort() { if (isIncrease) { highLight(1); int i, j; for (i = 0; i< num; i++) { highLight(2); setlbPoint(lbPoint1, i, "i = "); for (j = num - 1; j > i; j--) { highLight(3); highLight(4); setlbPoint(lbPoint2, j, "j = "); if(array[j]< array[j-1]) { int temp = array[j]; array[j] = array[j - 1]; array[j - 1] = temp; highLight(5); Swap(lbArrays[j - 1], lbArrays[j]); } } } highLight(0); } else { highLight(1); int i, j; for (i = 0; i< num; i++) { highLight(2); setlbPoint(lbPoint1, i, "i = ");

13

for (j = num - 1; j > i; j--) { highLight(3); highLight(4); setlbPoint(lbPoint2, j, "j = "); if(array[j] > array[j-1]) { int temp = array[j]; array[j] = array[j - 1]; array[j - 1] = temp; highLight(5); Swap(lbArrays[j - 1], lbArrays[j]); } } } highLight(0); } }

3.2.15 Thuật toán sắp xếp xen

public void InsertionSort() { if (isIncrease) { int pos, i; highLight(1); int x; highLight(2); for (i = 1; i < num; i++) { highLight(3); setlbPoint(lbPoint1, i, "i = "); x = array[i]; highLight(4); pos = i - 1; highLight(5); while ((pos >= 0) && (array[pos] > x)) { highLight(6); setlbPoint(lbPoint2, pos, "j = "); array[pos + 1] = array[pos]; highLight(7); if (pos > 0 && array[pos - 1] <= x) { Move(lbArrays[pos + 1], lbArrays[pos], 0); }else { Move(lbArrays[pos + 1], lbArrays[pos], pos);} pos--; highLight(8); } highLight(9); array[pos + 1] = x; setlbPoint(lbPoint2, -1, null);} highLight(0);} else { int pos, i; highLight(1); int x; highLight(2); for (i = 1; i < num; i++) { highLight(3); setlbPoint(lbPoint1, i, "i = "); x = array[i]; highLight(4); pos = i - 1; highLight(5);

14

while ((pos >= 0) && (array[pos] < x)) { highLight(6); setlbPoint(lbPoint2, pos, "j = "); array[pos + 1] = array[pos]; highLight(7); if (pos > 0 && array[pos - 1] >= x) { Move(lbArrays[pos + 1], lbArrays[pos], 0); }else { Move(lbArrays[pos + 1], lbArrays[pos], pos);} pos--; highLight(8); } array[pos + 1] = x; highLight(9); setlbPoint(lbPoint2, -1, null); } highLight(0); } }

3.2.16 Thuật toán sắp xếp vun đống

public void HeapSort() { int r; int xend = ((int) ((18 - num) * 0.5) * 70) + 100 + (num - 1) * 70; HeapLocationInit(); highLight(2); CreateHeap(); highLight(3); r = num - 1; while (r > 0) { highLight(4); highLight(5); int x = array[0]; array[0] = array[r]; array[r] = x; SwapHeapEnd(lbArrays[0], lbArrays[r], xend); xend -= 70; highLight(6); r --; highLight(7); if (r > 0) { highLight(8); Shift(0, r); } } SwapHeapEnd(lbArrays[0], null, xend); }

15

3.2.17 Thuật toán sắp xếp nhanh

public void QuickSort() { QuickSortAl(0, num - 1); QuickSortAnimation(); step = 0;} public void QuickSortAnimation() { int s, i, j; for (s = 0; s < step; s ++) { i = lbI[s]; j = lbJ[s]; setlbPoint(lbPoint1, i, "i = "); setlbPoint(lbPoint2, j, "j = "); if (i != j) { Coloring(lbArrays[(lbL[s] + lbR[s]) / 2], selectedGreen); Coloring(lbL[s], lbR[s], selectedYellow); Swap(lbArrays[i], lbArrays[j]); } if (lbL[s + 1] + lbR[s + 1] != lbL[s] + lbR[s]) { Coloring(lbArrays[(lbL[s] + lbR[s]) / 2], SystemColor.inactiveCaption); Coloring(lbL[s], lbR[s], SystemColor.inactiveCaption); } } }

3.2.18 Thuật toán sắp xếp trộn

public void MergeSort() { for (int i = 0; i < num; i ++) oriLocat[i] = lbArrays[i].getX(); MergeSortAl(0, num - 1); }

public void MergeSortAl(int left, int right) { highLight(1); if (left < right) { highLight(2); int mid = (left + right) / 2; MergeSortAl(left, mid); MergeSortAl(mid + 1, right); Merge(left, mid, right); } }

16

III. THIẾT KẾ GIẢI THUẬT (LƯU ĐỒ - NGÔN NGỮ GIẢ)

17

IV. GIỚI THIỆU CHƯƠNG TRÌNH

3.4.1 Giao diện chính

18

Giao diện chính được chia làm 3 khu vực lớn: tiêu đề, khung chạy mô phỏng, khu vực

chức năng. - Khu vực tiêu đề có chứa các thành phần:

+ Nút hướng dẫn: mở Form hướng dẫn sử dụng phần mềm theo từng bước.

+ Tên phần mềm.

+ Nút thông tin: mở Form thông tin về phần mềm.

- Khu vực khung chạy mô phỏng chứa khung chạy mô phỏng các thuật toán sắp xếp

bằng giao diện đồ hoạ.

- Khu vực chức năng được chia làm 4 khu vực nhỏ:

+ Dữ liệu: gồm Khởi tạo mảng và Tạo dữ liệu mảng

Khởi tạo mảng: các chức năng khởi tạo mảng như: Tạo mảng, Đặt về

0 và Xoá mảng.

Tạo dữ liệu mảng: chứa 3 cách tạo dữ liệu mảng: tạo ngẫu nhiên, nhập

bằng tay và nhập từ tập tin.

+ Code: hiển thị code của các giải thuật sắp xếp. Trong khung này còn có thêm

thanh trượt để điều chỉnh độ to nhỏ của code.

+ Chọn thuật toán: chứa danh sách 6 thuật toán được chia theo 2 nhóm: Đơn

giản và Phức tạp.

+ Điều khiển: chức các chức năng: tuỳ chọn sắp xếp tăng dần, giảm dần; nút

Sắp xếp để thực hiện quá trình sắp xếp; nút Dừng để dừng quá trình sắp xếp;

thanh trượt điều chỉnh tốc độ sắp xếp.

3.4.2 Giao diện hướng dẫn sử dụng

19

Giao diện Hướng dẫn sử dụng được gọi khi click chuột vào nút “Hướng dẫn” trên giao

diện chính. Giao diện này có 4 Tab chính tương ứng với 4 bước sử dụng phần mềm.

Tab 1: Bước 1 – Khởi tạo mảng: tab này sẽ hướng dẫn người dùng cách khởi tạo mảng.

Tab 2: Bước 2 – Tạo dữ liệu mảng: tab này chứa 3 tab nhỏ tương ứng với 3 cách tạo dữ

liệu mảng, bao gồm: tạo ngẫu nhiên, nhập bằng tay và nhập từ tập tin.

Tab 3: Bước 3 – Chọn thuật toán: hướng dẫn người dùng click chọn thuật toán sắp xếp cần

mô phỏng.

Tab 4: Bước 4 – Tuỳ chỉnh và sắp xếp: tab này sẽ hướng dẫn người dùng bước cuối cùng

là thiết lập các tuỳ chỉnh về độ to nhỏ của code, thứ tự sắp xếp (tăng dần, giảm dần) và tốc

độ sắp xếp để tiến hành mô phỏng sắp xếp.

Ngoài ra, người dùng còn có thể xem hướng dẫn sử dụng phần mềm bằng hình ảnh tại phụ

lục Chương I.

3.4.3 Giao diện thông tin phần mềm

Giao diện thông tin phần mềm được gọi khi click vào nút “Thông tin” trên giao diện chính.

Giao diện này chứa các thông tin của phần mềm về: trường, khoa, đồ án, học kỳ, cán bộ

hướng dẫn và sinh viên thực hiện phần mềm.

20

3.4.4 Giao diện nhập dữ liệu mảng bằng tay

Giao diện nhập dữ liệu mảng bằng tay được gọi khi click vào nút “Bằng tay” trên giao

diện chính. Giao diện này chứa ô nhập số lượng phần tử của mảng và giá trị của từng

phần tử tương ứng với số lượng đó.

CHƯƠNG 4. KẾT LUẬN – ĐÁNH GIÁ

I. KẾT QUẢ ĐẠT ĐƯỢC

4.1.1 Về mặt chuyên môn

- Nắm vững hơn kiến thức cấu trúc dữ liệu và giải thuật về các thuật toán sắp xếp.

- Hoàn tất được phần mềm “Mô phỏng các thuật toán sắp xếp” với yêu cầu đã đề ra

là: có giao diện đồ hoạ mô phỏng lại từng thao tác xử lý theo từng dòng code đối

với mỗi thuật toán sắp xếp.

- Học được cách sử dụng Thread, tạo chuyển động trên form.

- Đóng gói được phần mềm và ghi ra đĩa.

4.1.2 Về mặt kinh nghiệm

- Biết cách sử dụng Thread, tạo chuyển động trên form. Có thể vận dụng được trong

quá trình tìm hiểu sau này.

- Biết cách viết tài liệu theo mẫu chuẩn.

- Biết đánh giá giao diện phù hợp với cảm quang của người dùng thực tế.

21

II. HẠN CHẾ VÀ NGUYÊN NHÂN

Hạn chế Nguyên nhân

Số lượng phần tử còn hạn chế, chỉ được 15

phần tử trên form.

Độ lớn của form có giới hạn, chưa nắm rõ

được cách tạo form động.

Giao diện đồ hoạ chưa thực sự mượt mà,

đẹp và ấn tượng.

Vận dụng chưa tốt Thread và các hàm liên

quan để tạo chuyển động mượt.

Còn mắc lỗi trong quá trình chạy giao diện

đồ hoạ.

Kiến thức về Thread và chuyển động đồ

hoạ trên form chưa nhiều.

Gặp nhiều khó khăn trong xử lý Thread. Kiến thức về Thread chưa nhiều.

Còn ít chức năng, cần cải tiến thêm các

chức năng nổi bật hơn.

Vấn đề về kiến thức và thời gian tìm hiểu

chưa chuyên sâu.

III. HƯỚNG PHÁT TRIỂN

- Thêm nhiều phần tử hơn khi sắp xếp.

- Thêm nhiều hiệu ứng chuyển động khác.

- Thêm loại sắp xếp khác như: sắp xếp đồ vật, sắp xếp cột, sắp xếp hàng,...

- Thêm chức năng so sánh hai thuật toán sắp xếp cùng lúc.

- Làm cho giao diện thân thiện và đẹp hơn.

- Có thêm chức năng tạm dừng và tiếp tục sắp xếp.

- Có thêm bộ đếm thời gian và đồng bộ bộ đếm thời gian này với tốc độ sắp xếp.

- Phát triển trên ứng dụng web và thiết bị di động.

22

PHỤ LỤC

CHƯƠNG 1. HƯỚNG DẪN SỬ DỤNG PHẦN MỀM

Có 3 cách để người dùng có thể xem hướng dẫn sử dụng phần mềm:

- Cách 1: Xem hướng dẫn thông qua giao diện “Hướng dẫn sử dụng”.

- Cách 2: Xem hướng dẫn bằng video trên Youtube: https://youtu.be/YPJ_ZYjEfQw

- Cách 3: Xem hướng dẫn bằng hình ảnh dưới đây.

Bước 1: Tạo mảng

Bước 2: Tạo dữ liệu mảng

23

Bước 3: Chọn thuật toán

Bước 4: Tuỳ chỉnh và sắp xếp

24

CHƯƠNG 2. TÀI LIỆU THAM KHẢO

[1] Aho A.V. , Hopcroft J.E. and Ullman J.D. Data Structures and Algorithms. Pages:

200-345. Addison-Wesley. London, 1983.

[2] Đinh Mạnh Tường. Cấu trúc dữ liệu & Thuật toán. Chương 1 và 8. Nhà xuất bản

khoa học và kỹ thuật. Hà nội, 2001.

[3] Nguyễn Văn Linh. Giáo trình Phân tích & thiết kế thuật toán. Chương 1 và 2. Trang:

1-45. Nhà xuất bản Đại học Cần Thơ. Cần Thơ, 2009.

[4] http://o7planning.org/vi/10269/huong-dan-lap-trinh-da-luong-trong-java

[5] http://vietjack.com/java/multithread_trong_java.jsp

[6] https://vi.wikipedia.org/wiki/Thuật_toán_sắp_xếp

Ngoài ra, còn có tham khảo thêm các câu hỏi trong stackoverflow.com và các forum khác.