Tiểu 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. th s.gvc võ huỳnh trâm

1. 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

2. ĐÁ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

3. 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

4. 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

5. 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).

6. 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.

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

8. 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.

9. 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);
}

10. 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();

11. 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("8n" + "1n" + "2n" + "3n" + "4n" + "5n" + "1n" +
"5n" + "8n");
}
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) {

12. 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();
}
}
});

13. 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();
}
Tải bản FULL (28 trang): https://bit.ly/3d38T7R
Dự phòng: fb.com/TaiHo123doc.net

14. 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 {
6709847