Báo cáo đồ án lập trình

Báo cáo Đồ án Lập trình

TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI
VIỆN CÔNG NGHỆ THÔNG TIN VÀ TRUYỀN THÔNG
-----□□&□□-----

BÁO CÁO ĐỒ ÁN LẬP TRÌNH
Đề tài: Lập trình Python và Xây dựng Cấu trúc dữ liệu
và Giải thuật với Python. Tìm hiểu về Machine Learning.

Giảng viên hướng dẫn:

PGS.TS. Đỗ Phan Thuận

Môn học:

Đồ án lập trình – IT3914

Viện:

Cơng nghệ thơng tin và truyền thông

Sinh viên thực hiện

Đỗ Trường Thịnh – 20193124

HÀ NỘI, tháng 8, năm 2022

1

Báo cáo Đồ án Lập trình

Nợi dung
LỜI MỞ ĐẦU 4
CHƯƠNG 1. TỔNG QUAN VỀ PYTHON..............................................................5
1.1.

Giới thiệu...........................................................................................................................................5

1.2.

Một số khái niệm cơ bản trong Python..........................................................................................6

1.3.

1.4.

1.5.

1.2.1.

Comment..............................................................................................................................6

1.2.2.

Biến.......................................................................................................................................6

1.2.3.

Đầu vào.................................................................................................................................6

1.2.4.

Các toán tử cơ bản..............................................................................................................6

Cấu trúc dữ liệu trong Python........................................................................................................7
1.3.1.

Một số kiểu dữ liệu.............................................................................................................7

1.3.2.

Cấu trúc điều khiển............................................................................................................7

1.3.3.

Các cấu trúc dữ liệu............................................................................................................8

Một số thư viện trong Python..........................................................................................................9
1.4.1.

NumPy..................................................................................................................................9

1.4.2.

SciPy.....................................................................................................................................9

1.4.3.

Pandas..................................................................................................................................9

1.4.4.

Scikit-learn........................................................................................................................10

1.4.5.

Matplotlib..........................................................................................................................10

Hàm trong Python..........................................................................................................................10

CHƯƠNG 2: XÂY DỰNG CÁC CTDL> VỚI PYTHON................................12
2.1.

2.2.

Cấu trúc dữ liệu và giải thuật cơ bản...........................................................................................12
2.1.1.

Mảng...................................................................................................................................12

2.1.2.

Ngăn xếp............................................................................................................................12

2.1.3.

Hàng đợi.............................................................................................................................14

2.1.4.

Danh sách liên kết đơn.....................................................................................................15

2.1.5.

Giải thuật tìm kiếm...........................................................................................................19

2.1.6.

Giải thuật sắp xếp.............................................................................................................23

2.1.7.

Cấu trúc dữ liệu cây.........................................................................................................26

Giải thuật nâng cao.........................................................................................................................30
2.2.1.

Thuật toán tham lam........................................................................................................30

2.2.2.

Thuật toán quay lui..........................................................................................................32

2.2.3.

Thuật tốn Quy hoạch đợng............................................................................................34
2

Báo cáo Đồ án Lập trình

2.2.4.

Thuật tốn Chia để trị......................................................................................................36

2.2.5.

Thuật tốn BFS và DFS trên đồ thị................................................................................37

CHƯƠNG 3: TÌM HIỂU VỀ MACHINE LEARNING........................................42
3.1. Giới thiệu về Machine Learning...........................................................................................................42
3.2. Dữ liệu trong Machine Learning..........................................................................................................43
3.2.1. Làm việc với file .csv............................................................................................................43
3.2.2. Hình dung dữ liệu...............................................................................................................44
3.2.3. Chuyển đổi dữ liệu...............................................................................................................45

KẾT LUẬN

49

DANH MỤC THAM KHẢO...................................................................................50

3


Báo cáo Đồ án Lập trình

LỜI MỞ ĐẦU
Ngày nay trong cuộc sống 4.0 của chúng ta gần như không thể thiếu được những

khái niệm liên quan đến công nghệ thông tin, từ các phương tiện truyền thông, xã
hội cho đến lĩnh vực kinh doanh, quản lý….. Mọi thứ đều cần những phần mềm
cũng như sản phẩm của công nghệ thông tin đễ hỗ trợ giúp nâng cao phát triển
vững mạnh hơn.Ví dụ trong lĩnh vực kinh doanh bn bán hàng hóa theo cách
truyền thống vẫn cịn tồn tại nhiều nhược điểm như thống kê chi tiết chưa chính
xác, quy trình thanh tốn chưa được chặt chẽ và nhanh chóng. Cùng với sự phát
triển của nhiều ngơn ngữ lập trình web như PHP, Ruby, Scheme thì Python là một
cái tên đáng chú ý. Hiện nay ngôn ngữ Python được xếp hạng thứ 1 trong Top 10
các ngơn ngữ lập trình phổ biến nhất đang được thế giới sử dụng. Python là một
ngơn ngữ có hình thái rất sáng sủa, cấu trúc rõ ràng, thuận tiện cho người mới bắt
đầu học lập trình. Cấu trúc của Python cịn cho phép người sử dụng viết mã lệnh
với số lần gõ phím tối thiểu nhất. Python là một ngơn ngữ lập trình đơn giản nhưng
lại rất hiệu quả. Bên cạnh đó, Python là một ngơn ngữ có tính hướng đối tượng cao.
Với ngơn ngữ lập trình python là một ngơn ngữ lập trình đa năng với nhiều ưu
điểm vượt trội, và đang đứng ở vị trí số một trong top các ngơn ngữ lập trình hiện
nay.
Trong bài báo cáo này, em sẽ trình bày những kiến thức em đã tìm hiểu trong học
kỳ vừa qua về ngơn ngữ lập trình Python và Học máy. Bài báo cáo được tổ chức
như sau:

CHƯƠNG 1: TỔNG QUAN VỀ PYTHON. Chương này nghiên cứu tìm
hiểu ngơn ngữ lập trình Python gồm các khái niệm, các cấu trúc dữ liệu, một số thư
viện phổ biến.
CHƯƠNG 2: XÂY DỰNG CÁC CTDL> VỚI PYTHON. Chương này
sẽ xây dựng lại một số giải thuật cơ bản và nâng cao với ngôn ngữ lập trình Python.
CHƯƠNG 3: TÌM HIỂU VỀ MACHINE LEARNING. Chương này nghiên
cứu tìm hiểu các khái niệm tổng quan về Học máy.

4

Báo cáo Đồ án Lập trình

CHƯƠNG 1. TỔNG QUAN VỀ PYTHON
1.1. Giới thiệu
Lịch sử hình thành
Python đã được hình thành vào cuối những năm 1980 và được bắt đầu thực hiện
vào tháng 12/1989 bởi Guido van Rossum tại CWI tại Hà Lan như là người kế thừa
của ngôn ngữ ABC (tự lấy cảm hứng từ SETL) có khả năng xử lý ngoại lệ và giao
tiếp với hệ điều hành Amoeba. Van Rossum là tác giả chính của Python, và vai trị
trung tâm của ơng tiếp tục trong việc quyết định hướng phát triển của Python được
phản ánh trong tiêu đề mà cộng đồng Python dành cho ông “Độc tài nhân từ cho
cuộc sống” (benevolent dictator for life)(BDFL).
Python 2. 0 được phát hành vào ngày 16/10/2000, với nhiều tính năng chính mới
bao gồm một bộ dọn rác đầy đủ và hỗ trợ Unicode. Với phiên bản này, quá trình
phát triển đã được thay đổi và trở thành minh bạch hơn và được cộng đồng ủng hộ.
Python 3. 0 (còn được gọi là Python 3000 hoặc Py3k), một bản phát hành lớn,
không tương thích ngược, được phát hành vào ngày 03/12/2008 sau một thời gian
dài thử nghiệm. Nhiều trong số các tính năng chính của nó đã được điều chỉnh để
tương thích ngược với Python 2. 6 và 2. 7. Các tính năng và triết lý phát triển
Python là 1 ngôn ngữ lập trình đa hình: lập trình hướng đối tượng và hướng cấu
trúc được hỗ trợ đầy đủ, và có 1 số tính năng của ngơn ngữ hỗ trợ lập trình theo
chức năng và lập trình hướng khía cạnh (Aspect-oriented programming). Nhiều mơ
hình khác được hỗ trợ bằng việc sử dụng các phần mở rộng, bao gồm thiết kế theo
hợp đồng (design by contract) và lập trình luận lý.
Các trang như Mozilla, Reddit, Instagram và PBS đều được viết bằng Python.
Ngôn ngữ lập trình Python được dùng vào các mục đích:
 Phát triển web (trên máy chủ)
 Phát triển phần mềm 17
 Tính tốn một cách khoa học

 Lên kịch bản cho hệ thống
Python cũng hỗ trợ hàm, thủ tục, hay kể cả lập trình hướng đối tượng.
Để viết mã nguồn Python, ta có thể sử dụng bất kỳ một trình soạn thảo nào, kể cả
những trình soạn thảo đơn giản nhất như NotePad. Tuy nhiên, để phát triển các ứng
5


Báo cáo Đồ án Lập trình

dụng một cách hiệu quả hơn, ta nên sử dụng một IDE, để có thể tiết kiệm thời gian
và công sức viết code.

1.2. Một số khái niệm cơ bản trong Python
1.2.1. Comment
Comment hay còn gọi là chú thích được dùng để giải thích các dịng code, giúp cho
người đọc hay chính người viết code sau này hiểu được source code dễ dàng hơn.
Các ký tự và đoạn code trong comment sẽ không ảnh hưởng tới kết quả chương
trình.
Trong Python có 2 loại comment là comment trên một dòng và comment trên nhiều
dòng.
Comment trên 1 dòng: Comment trên một dòng sẽ được bắt đầu với ký tự #.
Comment trên nhiều dòng: Comment trên nhiều dòng trong ngơn ngữ lập trình
Python sẽ bắt đầu bằng 3 dấu nháy đơn (''') hoặc 3 dấu nháy kép (""") và kết thúc
cũng bằng 3 dấu nháy đơn (''') hoặc 3 dấu nháy kép (""").
1.2.2. Biến
Khái niệm biến trong lập trình cũng giống khái niệm biến trong toán
học, biến được sử dụng để lưu trữ dữ liệu trong chương trình. Dữ liệu được lưu
trữ trong một biến có thể thay đổi trong khi chạy chương trình.
1.2.3. Đầu vào
Để nhập dữ liệu đầu vào, ta dùng hàm input(). Ví dụ:

# Nhập dữ liệu cho biến name từ bàn phím
name = input()
print("Hello " + name)

Khi nhập dữ liệu cho một biến từ bàn phím thì kiểu dữ liệu của biến đó ln
là str (kể cả bạn có nhập giá trị số cho biến đó).
Vì vậy khi muốn kiểu dữ liệu nhập vào là ở dạng khác như int, float,… chúng ta
cần ép kiểu cho đầu vào. Ví dụ ép kiểu với kiểu dữ liệu int:
age = int(input())

1.2.4. Các toán tử cơ bản
6


Báo cáo Đồ án Lập trình

Python xây dựng 7 loại hình tính tốn trên tốn tử như sau:
 Python Arithmetic Operator (toán tử số học): +, -, *, /, **, //, %
 Python Relational Operator (toán tử quan hệ): >, <, >=, <=, ==, !=
 Python Assignment Operator (toán tử gán): =, +=, -=, /=, *=, **=, //=, %=
 Python Membership Operator (toán tử membership): in, not in
 Python Identity Operator (toán tử identity): is, is not
 Python Logical Operator (toán tử logic): and, or, not
 Python Bitwise Operator (toán tử thao tác bit)

1.3. Cấu trúc dữ liệu trong Python
1.3.1. Một số kiểu dữ liệu
Một số kiểu dữ liệu cơ bản trong Python:
 int: đây là kiểu dữ liệu được dùng để lưu trữ các số nguyên (1, 2, 3, 4, ...).
 float: đây là kiểu dữ liệu dùng để lưu trữ các biến kiểu số thực (1.43, 5.34,

3.333, ...).
 bool: đây là kiểu dữ liệu dùng để lưu trữ các giá trị luận lý (True hoặc False)
 str: đây là kiểu dữ liệu dùng để lưu trữ các xâu ký tự ("Viet
Nam", "Codelearn", ...)
1.3.2. Cấu trúc điều khiển
Câu lệnh điều kiện
 Câu lệnh if được sử dụng để kiểm tra một điều kiện: nếu điều kiện là đúng sẽ
chạy một khối các câu lệnh.
if condition:
…
else:
…

 Khối else sẽ được thực thi nếu điều kiện trong if là sai
7


Báo cáo Đồ án Lập trình

 Sử dụng elif hoặc câu lệnh điều kiện lồng nhau trong trường hợp câu lệnh có
3 nhánh.
Cấu trúc vịng lặp
Trong Python có 2 kiểu vòng lặp: for và while.
Vòng lặp for: Vòng lặp for ở trong Python có tác dụng lặp các biến dữ liệu có kiểu
dữ liệu list, tuple hoặc string,... Sử dụng cú pháp như sau:
for variable in data:
# code

Hàm range()
range(start, stop [, step])

Hàm range() có 3 tham số:
 start: số nguyên bắt đầu, chuỗi sẽ bắt đầu với tham số này. Giá trị mặc định là
0.
 stop: số nguyên kết thúc, chuỗi sẽ kết thúc với tham số này.
 step: số nguyên xác định khoảng cách giữa các số bên trong chuỗi. Giá trị
mặc định là 1.
Kết hợp range với for cho phép tạo vòng lặp dễ dàng hơn:
for number in range(5):
print(number)

 vòng lặp while lặp khi thỏa mãn điều kiện cho trước. Cú pháp:
while <condition>:
# code

 break và continue: break cho phép thốt khỏi vịng lặp, cịn continue cho
phép bỏ qua lượt chạy hiện tại của vòng lặp và chạy tiếp.
1.3.3. Các cấu trúc dữ liệu
Trong Python có 4 kiểu cấu trúc dữ liệu là List, Tuple, Set và Dictionary.
8


Báo cáo Đồ án Lập trình

List: Được sử dụng để lưu trữ dữ liệu của các loại dữ liệu khác nhau một cách tuần
tự. Có các địa chỉ được gán cho mọi thành phần của danh sách, được gọi là Index.
Giá trị chỉ mục bắt đầu từ 0 và tiếp tục cho đến khi phần tử cuối cùng được gọi là
chỉ số dương.
Dictionary: Được sử dụng để lưu trữ các cặp key-value. Để hiểu rõ hơn, hãy nghĩ
đến một thư mục điện thoại nơi hàng trăm và hàng ngàn tên và số tương ứng của

chúng đã được thêm vào. Bây giờ các giá trị không đổi ở đây là Tên và Số điện
thoại được gọi là các phím. Và các tên và số điện thoại khác nhau là các giá trị đã
được đưa vào các phím. Nếu truy cập các giá trị của các phím, sẽ nhận được tất cả
tên và số điện thoại. Vì vậy, đó là những gì một cặp key-value. Và trong Python,
cấu trúc này được lưu trữ bằng Dictionary.
Set: Là một tập hợp các yếu tố khơng có thứ tự là duy nhất. Có nghĩa là ngay cả khi
dữ liệu được lặp lại nhiều lần, nó sẽ chỉ được nhập vào tập hợp một lần.
Tuple (các bộ dữ liệu): Tuples giống như các list với ngoại lệ là dữ liệu một khi
được nhập vào bộ dữ liệu khơng thể thay đổi bất kể điều gì. Ngoại lệ duy nhất là
khi dữ liệu bên trong Tuple có thể thay đổi, chỉ sau đó dữ liệu Tuple có thể được
thay đổi.

1.4. Một số thư viện trong Python
1.4.1. NumPy
Được tạo bởi Travis Oliphant, NumPy là một “ngựa kéo” phân tích thực sự của
Python. Nó cung cấp cho người dùng cách làm việc với các mảng nhiều chiều,
cùng một số lượng lớn các hàm để xử lý trên các toán tử tốn học nhiều chiều trên
các mảng đó. Mảng là các khối dữ liệu được sắp xếp theo nhiều chiều dựa trên các
véc tơ và ma trận trong toán học. Mảng thường hữu ích khơng chỉ trong việc lưu dữ
liệu mà cả việc tính tốn nhanh các ma trận, điều không thể thiếu khi giải quyết các
vấn đề liên quan đến khoa học dữ liệu.
1.4.2. SciPy
Là một dự án gốc bởi Travis Oliphant, Pearu Peterson, and Eric Jones, SciPy hoàn
thiện các tính năng của NumPy, nhằm cung cấp các thuật tốn cho đại số tuyến
tính, khơng gian ma trận, xử lý tín hiệu và xử lý ảnh, tối ưu, biến đổi Fourier, …
1.4.3. Pandas
Pandas là thư viện thực hiện mọi thứ mà NymPy và SciPy khơng thể làm. Nó làm
việc với các đối tượng cấu trúc dữ liệu, DataFrames và Chuỗi (Series). pandas cho
phép bạn có thể xử lý các bảng dữ liệu phức tạp của nhiều loại khác nhau (điều mà
9

Báo cáo Đồ án Lập trình

các mảng của NumPy thơng thể làm được) và chuỗi thời gian. Bạn sẽ dễ dàng tải
dữ liệu từ nhiều nguồn khác nhau, sau đó slide, dice, xử lý các thành phần còn
thiếu, thêm, đổi tên, tổng hợp (aggregate), reshape và cuối cùng là trực quan dữ
liệu theo ý của bạn.
1.4.4. Scikit-learn
Bắt đầu như một phần của SciKits, Scikit-learn là lõi hoạt động của khoa học dữ
liệu trên Python. Nó cung cấp tất cả những gì bạn cần để tiền xử lý dữ liệu, học
giám sát và khơng giám sát, lựa chọn mơ hình, validate và error metrics.
1.4.5. Matplotlib
Matplotlib là một thư viện vẽ đồ thị cho ngơn ngữ lập trình Python và phần mở
rộng tốn học số NumPy của nó. Nó cung cấp một API hướng đối tượng để nhúng
các lô vào ứng dụng bằng cách sử dụng các bộ cơng cụ GUI có mục đích chung
như Tkinter, wxPython, Qt hoặc GTK.

1.5. Hàm trong Python
Trong Python, hàm là một nhóm các lệnh có liên quan đến nhau được dùng để thực
hiện một tác vụ, nhiệm vụ cụ thể nào đó. Hàm giúp chia chương trình Python thành
những khối/phần/mơ-đun nhỏ hơn. Khi chương trình Python quá lớn, hoặc cần mở
rộng, thì các hàm giúp chương trình có tổ chức và dễ quản lý hơn.
Cú pháp khai báo hàm
def ten_ham(tham số/đối số):
# Các câu lệnh

Gọi hàm
Ví dụ:
#Khai báo hàm

def phep_cong(a,b):
print(a+b)
#Gọi hàm
phep_cong(3+5)

Lệnh return:
Lệnh return thường được dùng để thốt hàm và trở về nơi mà tại đó hàm được gọi.
10


Báo cáo Đồ án Lập trình

Cú pháp của lệnh return:
return [danh_sach_bieu_thuc]

Lệnh này có thể chứa biểu thức được tính tốn và giá trị trả về. Nếu khơng có biểu
thức nào trong câu lệnh hoặc khơng có lệnh return trong hàm thì hàm sẽ trả về
None.
Phạm vi biến
Biến tồn cục: Các biến được khai báo ở bên ngoài tất cả các hàm thì được gọi là
biến tồn cục (external or global variable). Các biến tồn cục có thể truy xuất và sử
dụng ở mọi hàm trong chương trình. Biến tồn cục cũng tồn tại cho tới khi chương
trình kết thúc.
Biến cục bộ: Các biến được khai báo trong 1 hàm được gọi là các biến cục bộ. Các
biến cục bộ này chỉ tồn tại và chỉ có thể sử dụng bên trong hàm trong khi hàm đó
đang thực thi.

11

Báo cáo Đồ án Lập trình

CHƯƠNG 2: XÂY DỰNG CÁC CTDL> VỚI PYTHON
2.1. Cấu trúc dữ liệu và giải thuật cơ bản
2.1.1. Mảng
Mảng là một phần cơ bản của tất cả các ngơn ngữ lập trình, nó là tập hợp các phần
tử của một kiểu dữ liệu duy nhất, ví dụ mảng số nguyên, mảng chuỗi. Không giống
như mảng, mỗi list có thể lưu trữ phần tử với bất kỳ kiểu dữ liệu nào và làm được
mọi thứ mà mảng có thể làm. Trong Python, khơng có cấu trúc dữ liệu mảng gốc
nên người ta thường sử dụng các list Python thay cho mảng.
Nếu muốn tạo mảng thực sự trong Python, ta cần phải sử dụng cấu trúc dữ liệu
mảng của NumPy. Để giải quyết các vấn đề toán học thì mảng NumPy sẽ hiệu quả
hơn.
Cách tạo mảng
import array as arr
a = arr.array('d',[1.1, 3.5, 4.5])
print(a)

Code trên tạo mảng có kiểu float. Chữ 'd' là mã kiểu, quyết định kiểu của mảng
trong quá trình tạo.
2.1.2. Ngăn xếp
Ngăn xếp (Stack) là một kiểu danh sách tuyến tính đặc biệt mà phép bổ sung và
phép loại bỏ được thực hiện ở một đầu, đầu đó gọi là đỉnh (Top). Trong đó, danh
sách (List) được xem như một tập có thứ tự nhưng bao gồm một số biến động các
phần tử. Hai phép bổ sung và loại bỏ được thực hiện thường xuyên. Điều này sẽ
khác biệt so với mảng (Array), khơng có phép bổ sung phần tử hay phép loại bỏ
phần tử. Danh sách tuyến tính là danh sách mà quan hệ lân cận giữa các phần tử
được xác định ra.
Cài đặt cấu trúc dữ liệu ngăn xếp sử dụng cấu trúc lưu trữ kế tiếp với phần tử
dữ liệu là số nguyên:

# Xay dung lop
class Stack:

12


Báo cáo Đồ án Lập trình

# Ham khoi tao
def __init__(self):
self.s = []
# Ham bo sung
def push(self, x):
self.s.append(x)
# Ham loai bo
def pop(self):
if len(self.s) == 0:
return "stack is empty"
return self.s.pop()
# Ham kiem tra Ngan xep rong
def is_empty(self):
return len(self.s) == 0
# Ham tra ve gia tri dinh
def top(self):
if len(self.s) == 0:
return "stack is empty"
return self.s[-1]
# Ham tinh do dai Ngan xep
def __len__(self):
return len(self.s)

# Ham hien thi cac phan tu trong Ngan xep
def __str__(self):
return "Stack is " + str(self.s)
13


Báo cáo Đồ án Lập trình

2.1.3. Hàng đợi
Cũng giống như ngăn xếp, hàng đợi là một cấu trúc dữ liệu tuyến tính. Hàng đợi
lưu trữ các mục sử dụng nguyên tắc FIFO (Nhập trước xuất trước) để chèn và
xóa.
Cách triển khai hàng đợi trong Python
Có nhiều cách khác nhau để triển khai hàng đợi trong Python. Các cách phổ
biến là:
 Sử dụng cấu trúc dữ liệu Danh sách dựng sẵn.
 Sử dụng thư viện collection.deque
Triển khai một hàng đợi trong Python với một danh sách
Phương thức append () và pop () của danh sách được sử dụng để chèn và xóa
các phần tử khỏi hàng đợi.
# Tạo 1 hàng đợi
queue = []
# Thêm phần tử vào hàng đợi
queue.append('Python')
queue.append('Javascript')
queue.append('Typescript')
print(queue)

Đầu ra
['Python', 'Javascript', 'Typescript']

# Xóa phần tử từ hàng đợi
print(queue.pop(0))
print(queue.pop(0))
print(queue.pop(0))

14


Báo cáo Đồ án Lập trình

print(queue)

Đầu ra
Python
Javascript
Typescript
[]

Triển khai hàng đợi bằng Python với collection.deque
Lớp deque từ mô-đun bộ sưu tập python cũng có thể được sử dụng để triển khai
hàng đợi. Nó hiệu quả hơn vì deque cung cấp các hoạt động xếp hàng và xếp hàng
nhanh hơn.
from collections import deque
queue = deque()
queue.append('Black')
queue.append('White')
queue.append('Orange')
print(queue)

Đầu ra
deque(['Black', 'White', 'Orange'])

2.1.4. Danh sách liên kết đơn
Danh sách liên kết đơn là một tập hợp các Node được phân bố động, được sắp xếp
theo cách sao cho mỗi Node chứa một giá trị (Data) và một con trỏ (Next). Con trỏ
sẽ trỏ đến phần tử kế tiếp của danh sách liên kết đó. Nếu con trỏ mà trỏ tới NULL,
nghĩa là đó là phần tử cuối cùng của linked list.
Tạo danh sách liên kết đơn
Trong Python, DSLK đơn có thể được biểu diễn như một lớp và mỗi nút là một lớp
riêng biệt khác như sau:

15


Báo cáo Đồ án Lập trình

# Lớp Node
class Node:
# Hàm khởi tạo đối tượng nút
def __init__(self, data):
self.data = data
self.next = None
# Lớp Linked List
class LinkedList:
# Hàm khởi tạo đối tượng Linked List
def __init__(self):
self.head = None

Chương trình sau sẽ tạo một DSLK đơn gồm 3 nút:

class Node:

def __init__(self, data):
self.data = data # Assign data
self.next = None # Initialize next as null
class LinkedList:
def __init__(self):
self.head = None

if __name__=='__main__':

# Khởi đầu với danh sách rỗng
llist = LinkedList()

16


Báo cáo Đồ án Lập trình

# Tạo 3 nút có dữ liệu lần lượt là 1, 2, 3
llist.head = Node(1)
second = Node(2)
third = Node(3)

llist.head.next = second;# Liên kết nút đầu với nút 2
second.next = third; # Liên kết nút thứ 2 với nút thứ 3

Duyệt danh sách liên kết đơn
Giả sử đã có một DSLK đơn, duyệt DSLK đơn có nghĩa là truy cập tới từng nút của
DSLK bắt đầu từ nút đầu tiên đến nút cuối cùng và tiến hành các xử lý cần thiết với

mỗi thành phần của DSLK.
def printList(self):
temp = self.head
while (temp):
print (temp.data
temp = temp.next

Chèn nút mới vào đầu DSLK đơn:
# Hàm push() chèn nút mới vào đầu DSLK đơn
def push(self, new_data):
# 1. Tạo nút mới
# 2. và đặt dữ liệu cho nút mới
new_node = Node(new_data)
# 3. Cho con trỏ next của nút mới trỏ vào Head
new_node.next = self.head
# 4. Di chuyển head trỏ vào nút mới
self.head = new_node

Chèn nút mới vào sau prev_node:
17


Báo cáo Đồ án Lập trình

# Hàm chèn nút mới vào sau nút prev_node cho trước.
def insertAfter(self, prev_node, new_data):
# 1. Kiểm tra sự tồn tại của nút prev_node
if prev_node is None:
print ("Nút pre_node không thể rỗng.")
return

# 2. Tạo nút mới &
# 3. Đặt dữ liệu cho nút mới
new_node = Node(new_data)
# 4. Gán con trỏ next của nút mới là prev_node.next
new_node.next = prev_node.next
# 5. Cho next của prev_node trỏ vào new_node
prev_node.next = new_node

Chèn nút mới vào sau nút cuối:
# Hàm thêm nút mới vào sau nút cuối.
def append(self, new_data):
# 1. Tạo nút mới
# 2. Đặt dữ liệu cho nút mới
# 3. Cho next = None
new_node = Node(new_data)
# 4. Nếu DSLK là rỗng thì cho head trỏ vào nút mới
if self.head is None:
self.head = new_node
return
# 5. Ngồi ra thì di chuyển last về nút cuối
last = self.head
while (last.next):
last = last.next
# 6. Thay đổi next của nút cuối
last.next = new_node
18


Báo cáo Đồ án Lập trình

Xóa mợt nút khỏi danh sách liên kết đơn
# Xóa nút có giá trị khóa trong DSLK đơn
def deleteNode(self, key):
temp = self.head
# Nếu nút đầu có giá trị khóa thì xóa nút đầu
if (temp is not None):
if (temp.data == key):
self.head = temp.next
temp = None
return
while(temp is not None):
if temp.data == key:
break
prev = temp
temp = temp.next
if(temp == None):
return
# Xóa nút khỏi DSLK
prev.next = temp.next
temp = None

Tìm kiếm một nút trong danh sách liên kết đơn
# Kiểm tra nút có giá trị khóa x có trong DSLK khơng
def search(self, x):
current = self.head
while current != None:
if current.data == x:
return True # tìm thấy
current = current.next
return False # khơng tìm thấy

19


Báo cáo Đồ án Lập trình

2.1.5. Giải thuật tìm kiếm
Tìm kiếm tuyến tính (Linear Search)
# python program for linear search using for loop
#define list
lst = []
#take input list size
num = int(input("Enter size of list :- "))
for n in range(num):
#append element in list/array
numbers = int(input("Enter the array of %d element :- " %n))
lst.append(numbers)
#take input number to be find in list
x = int(input("Enter number to search in list :- "))
# Recursive function to linear search x in arr[l..r]
def recLinearSearch( arr, l, r, x):
if r < l:
return -1
if arr[l] == x:
return l
if arr[r] == x:
return r
return recLinearSearch(arr, l+1, r-1, x)
res = recLinearSearch(lst, 0, len(lst)-1, x)
if res != -1:
20

Báo cáo Đồ án Lập trình

print('{} was found at index {}.'.format(x, res))
else:
print('{} was not found.'.format(x))

Tìm kiếm nhị phân (Binary Search)
#Trả về chỉ số của x trong arr nếu tồn tại, nếu khơng có sẽ trả về -1
def binary_search(arr, low, high, x):
#Trường hợp cơ sở
if high >= low:
mid = (high + low) // 2
#Nếu phần tử có tồn tại ở phần giữa của mảng
if arr[mid] == x:
return mid
#Nếu phần tử nhỏ hơn mid, nó sẽ nằm ở phía bên trái của mảng điểm gốc
là tử phần tử mid
elif arr[mid] > x:
return binary_search(arr, low, mid - 1, x)
#Nếu không, phần tử sẽ nằm bên phải
else:
return binary_search(arr, mid + 1, high, x)
else:
#Phần tử không tồn tại trong tập hợp
return -1
#Khởi tạo tập hợp
arr = [ 2, 3, 4, 10, 40 ]
x = int(input("Nhập phần tử cần tìm: "))

#Gọi hàm
result = binary_search(arr, 0, len(arr)-1, x)
if result != -1:
21


Báo cáo Đồ án Lập trình

print("Phần tử cần tìm có chỉ số là", str(result))
else:
print("Phần tử cần tìm khơng có trong mảng.")

Tìm kiếm nợi suy (Interpolation Search)
# If x is present in arr[0..n-1], then returns index of it, else returns -1.
def interpolationSearch(arr, lo, hi, x):
# Since array is sorted, an element present in array must be in range defined
by corner
if (lo <= hi and x >= arr[lo] and x <= arr[hi]):
# Probing the position with keeping uniform distribution in mind.
pos = lo + ((hi - lo) // (arr[hi] - arr[lo]) * (x - arr[lo]))
# Condition of target found
if arr[pos] == x:
return pos
# If x is larger, x is in right subarray
if arr[pos] < x:
return interpolationSearch(arr, pos + 1, hi, x)
# If x is smaller, x is in left subarray
if arr[pos] > x:
return interpolationSearch(arr, lo, pos - 1, x)
return -1

# Array of items in which search will be conducted
arr = [10, 12, 13, 16, 18, 19, 20, 21, 22, 23, 24, 33, 35, 42, 47]
n = len(arr)

22


Báo cáo Đồ án Lập trình

# Element to be searched
x = int(input("Nhập phần tử cần tìm kiếm: "))
index = interpolationSearch(arr, 0, n - 1, x)
if index != -1:
print("Phần tử cần tìm có chỉ số là", index)
else:
print("Khơng tồn tại phần tử cần tìm.")

2.1.6. Giải thuật sắp xếp
Sắp xếp nổi bọt (Bubble Sort)
def bubble_sort(alist):
for j in range(len(alist)-1,0,-1):
for i in range(j):
if alist[i] > alist[i+1]:
alist[i], alist[i+1] = alist[i+1], alist[i]
lst = [54,26,93,17,77,31,44,55,20]
bubble_sort(lst)
print(lst)

Sắp xếp chèn (Insertion Sort)
def insert_sort(alist):

for i in range(1, len(alist)):
for j in range(i, 0, -1):
if alist[j] < alist[j-1]:
alist[j], alist[j-1] = alist[j-1], alist[j]
lst = [54,26,93,17,77,31,44,55,20]
23


Báo cáo Đồ án Lập trình

insert_sort(lst)
print(lst)

Sắp xếp chọn (Selection Sort).
def selection_sort(alist):
n = len(alist)
for i in range(n-1):
min_index = i
for j in range(i+1, n):
if alist[j] < alist[min_index]:
min_index = j
if min_index != i:
alist[i], alist[min_index] = alist[min_index], alist[i]
lst = [54,226,93,17,77,31,44,55,20]
selection_sort(lst)
print(lst)

Sắp xếp trộn (Merge Sort)
def mergesort(arr):
if len(arr)>1:

mid=len(arr)//2
L=arr[:mid]
R=arr[mid:]
mergesort(L)
mergesort(R)
i=j=k=0
while i if L[i]arr[k]=L[i]

24


Báo cáo Đồ án Lập trình

i+=1
else:
arr[k]=R[j]
j+=1
k+=1
while iarr[k]=L[i]
i+=1
k+=1
while jarr[k]=R[j]
j+=1
k+=1
return arr
arr=[54,26,93,17,77,31,44,55,20]

print(*mergesort(arr))

Sắp xếp kiểu đồi (Shell Sort)
def shell_sort(alist):
n = len(alist)
gap = n / 2
while gap > 0:
for i in range(gap, n):
j=i
while j>=gap and alist[j-gap] > alist[j]:
alist[j-gap], alist[j] = alist[j], alist[j-gap]
j -= gap
gap = gap / 2
lst = [54,26,93,17,77,31,44,55,20]
25