Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

BỘ TÀI CHÍNH

TRƯỜNG ĐẠI HỌC TÀI CHÍNH – MARKETING

KHOA CÔNG NGHỆ THÔNG TIN



BÀI TẬP ĐỒ ÁN BÁO CÁO NỘI DUNG GIỮA KÌ

NỘI DUNG_CHỦ ĐỀ:

CẤU TRÚC QUẢN LÍ CÁC LỚP MẦM NON

GVHD: Th.S Nguyễn Quốc Thanh

SVTH: Nguyễn Ngọc Quỳnh Như

MSSV: 2221004251

Lớp: 22DHT01

1
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
DANH MỤC BẢNG
Bảng 1. 1Bảng dữ liệu thông tin các lớp mầm non..................................................................................3

DANH MỤC HÌNH ẢNH

Hình 2. 1 Kết quả test chương trình con nhập mảng.....................................................14
Hình 2. 2 Kết quả test chương trình con xuất mảng......................................................14
Hình 2. 3 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử đầu mảng).........15
Hình 2. 4 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử giữa mảng)........15
Hình 2. 5 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử cuối mảng)........15
Hình 2. 6 Kết quả test chương trình con tìm kiếm (không tìm thấy)............................15
Hình 2. 7 Kết quả test chương trình con ShakerSort.....................................................16
Hình 2. 8 Kết quả chạy chương trình con SelectionSort...............................................16
Hình 2. 9 Kết quả chạy chương trình con InterchangeSort...........................................17
Hình 2. 10 Kết quả chạy chương trình con
Hình 3. 2 Kết quả thử chức năng nhập danh sách liên kết............................................26
Hình 3. 3 Kết quả thử chức năng xuất danh sách liên kết.............................................26
Hình 3. 4 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử đầu mảng).........26
Hình 3. 5 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử giữa mảng)........27
Hình 3. 6 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử cuối mảng)........27
Hình 3. 7 Kết quả test chương trình con tìm kiếm (không tìm thấy)............................27
Hình 3. 8 Kết quả chạy chương trình con InsertionSort................................................27
Hình 3. 9 Kết quả chạy chương trình con SelectionSort...............................................28
Hình 3. 10 Kết quả chạy chương trình con InterchangeSort.........................................28
Hình 3. 11 Kết quả chạy chương trình con BubbleSort................................................29
BubbleSort
Hình 2. 11 Kết quả chạy chương trình con InsertionSort
Hình 2. 12 Kết quả chạy chương trình con QuickSort
Hình 2. 13 Kết quả chạy chương trình con MergeSort

MỤC LỤC
CHƯƠNG 1.................................................................................................GIỚI THIỆU
4
1. Giới thiệu chủ đề:..................................................................................................4
2. Cấu trúc: (mô tả cấu trúc được yêu cầu, chọn CTDL để thể hiện, khai báo/ định
nghĩa cấu trúc)..............................................................................................................4
a) Thông tin sinh viên cần quản lí:........................................................................4
b) Cấu trúc dữ liệu hỗ trợ quản lí thông tin lớp học :.............................................4
c) Định nghĩa cấu trúc sinh viên :..........................................................................4
3. Dữ liệu mẫu:..........................................................................................................5
4. Các chức năng: (liệt kê các chức năng sẽ xây dựng)............................................5

2
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
CHƯƠNG 2.........................CHỨC NĂNG TRÊN DANH SÁCH SỬ DỤNG ARRAY
6
1. Chức năng trên mảng cấu trúc :............................................................................6
a) Chương trình con nhập:.....................................................................................6
b) Chương trình xuất:.............................................................................................6
c) Chương trình con tìm kiếm bằng LinearSearch:................................................7
d) Chương trình con tìm kiếm bằng BinarySearch:...............................................8
e) Chương trình con hoán vị (swap):.....................................................................8
f) Chương trình con sắp xếp bằng ShakerSort:.....................................................9
g) Chương trình con sắp xếp bằng SelectionSort:..................................................9
h) Chương trình con sắp xếp bằng InterchangeSort:............................................10
i) Chương trình con sắp xếp bằng BubbleSort:...................................................10
j) Chương trình con sắp xếp bằng InsertionSort:................................................10
k) Chương trình con sắp xếp bằng QuickSort:.................................................10
l) Chương trình con sắp xếp bằng MergeSort:.................................................11
m) Kiểm tra: (hàm main kiểm tra chương trình con).........................................12
2. Kết quả chạy:.......................................................................................................14
CHƯƠNG 3...............CHỨC NĂNG TRÊN DANH SÁCH LIÊN KẾT LINKED LIST
20
1. Chức năng trên danh sách liên kết......................................................................20
a) Chương trình con khởi tạo danh sách liên kết:................................................20
b) Chương trình con nhập danh sách liên kết:.....................................................20
c) Chương trình con xuất danh sách liên kết:......................................................21
d) Chương trình con tìm kiếm LinearSearch:......................................................21
e) Chương trình con hoán vị (swap):...................................................................22
f) Chương trình con sắp xếp bằng InsertSort:.....................................................22
g) Chương trình con sắp xếp bằng SelectionSort:................................................23
h) Chương trình con sắp xếp bằng InterchangeSort:............................................23
i) Chương trình con sắp xếp bằng BubbleSort:...................................................24
j) Kiểm tra: (hàm main kiểm tra chương trình con)............................................24
2. Kết quả chạy:.......................................................................................................26
CHƯƠNG 4...................................................................................................KẾT LUẬN
29
1. Các chức năng đã thực hiện:...............................................................................29
a) Các chức năng đã thực hiện trong mảng cấu trúc Array:................................29
3
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
b) Các chức năng đã thực hiện trong mảng cấu trúc Array:................................29
2. Các chức năng chưa thực hiện (không có)..........................................................30

4
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

CHƯƠNG 1. GIỚI THIỆU

1. Giới thiệu chủ đề:
Cấu trúc quản lý các lớp mầm non với các thông tin: Mã lớp; Giáo viên chủ nhiệm;
Sĩ số; Tuổi; Số bé trai; Tỷ lệ bé trai/bé gái (Trai_Gai) trong lớp.
2. Cấu trúc: (mô tả cấu trúc được yêu cầu, chọn CTDL để thể hiện, khai báo/
định nghĩa cấu trúc)
a) Thông tin sinh viên cần quản lí:
- MaLop: Mã lớp, là các kí tự số có chiều dài tối đa 10 kí tự.
- GVCN: Giáo viên chủ nhiệm, là tên của giáo viên các lớp với chiều dài tối đa
khoảng 7 kí tự.
- SiSo: Sĩ số lớp, thể hiện số bé học sinh trong lớp.
- Trai: Số bé trai trong lớp.
- Trai_Gai : Tỷ lệ bé trai và bé gái trong lớp.
b) Cấu trúc dữ liệu hỗ trợ quản lí thông tin lớp học :
- MaLop : chuôi tối đa 10 kí tự
- GVCN : chuỗi tối đa 20 kí tự
- SiSo : số nguyên không âm (SiSo >=0)
- Tuoi : số nguyên không am (Tuoi >=0)
- Trai : số thực (vì cần sử dụng Trai là số thực để tính Tỷ lệ trai gái)
- Trai_Gai : số thực
- Hai dữ liệu hỗ trợ cho chương trình con sắp xếp hiệu quả cao QuickSort trong
mảng cấu trúc :
+ LopMamNon b[10]
+ LopMamNon c[10]
c) Định nghĩa cấu trúc sinh viên :
Định nghĩa cấu trúc sinh viên trong mảng cấu trúc :
struct LopMamNon
{
char MaLop[10];
char GVCN[20];
int SiSo;
int Tuoi;
float Trai;
float Trai_Gai;
};

Định nghĩa cấu trúc sinh viên trong danh sách liên kết:
typedef struct lmn
{
char MaLop[10];
char GVCN[20];
int SiSo;
int Tuoi;
float Trai;
float Trai_Gai;
} lmnType;

5
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
3. Dữ liệu mẫu:
Bảng 1. 1Bảng dữ liệu thông tin các lớp mầm non

Mã lớp 01 02 03 04 05
GVCN Trần Thị A Hoàng Ngọc B Nguyễn Thảo C Lê Thanh D Hồ Quỳnh E
Sĩ số 10 12 14 10 12
Tuổi 5 4 3 3 4
Số bé 4 6 10 6 6
trai
Tỷ lệ 4/(10-4) 6/(12-6) 10/(14-10) 6/(10-6) 6/(12-6)
bé trai/
bé gái

4. Các chức năng: (liệt kê các chức năng sẽ xây dựng)

Các chức năng trên mảng cấu trúc :
- Nhập danh sách các lớp
- Xuất danh sách các lớp
- Tìm thông tin lớp theo mã lớp bằng :
+ LinearSearch
+ BinarySearch
- Sắp xếp danh sách các lớp mầm non theo thứ tự mã lớp bằng :
+ ShakerSort
+ InterchangeSort
+ InsertionSort
+ SelectionSort
+ BubbleSort
+ QuickSort
+ MergeSort
Các chức năng trên danh sách liên kết:
- Nhập danh sách các lớp
- Xuất danh sách các lớp
- Tìm thông tin lớp theo mã lớp bằng :
+ LinearSearch
- Sắp xếp danh sách các lớp mầm non theo thứ tự mã lớp bằng :
+ InterchangeSort
+ InsertionSort
+ SelectionSort
+ BubbleSort

6
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
CHƯƠNG 2. CHỨC NĂNG TRÊN DANH SÁCH SỬ DỤNG
ARRAY
1. Chức năng trên mảng cấu trúc :
a) Chương trình con nhập:
Để nhập danh sách các lớp mầm non, cần xây dựng 2 chương trình con gồm:
- void Nhap_o (LopMamNon& a): hỗ trợ nhập 1 lớp mầm non gồm các thông
tin Mã lớp, Giáo viên chủ nhiệm, Sĩ số, Tuổi, Số bé trai, Tỷ lệ trai_gái.
- void Nhap_mang (LopMamNon a[], int n): hỗ trợ nhập danh sách các lớp
mầm non.
//ctrinh con nhap o cau truc
void Nhap_o(LopMamNon& a)
{
cout << " Ma Lop: ";
cin.getline(a.MaLop, 10);
cout << " GVCN: ";
cin.getline(a.GVCN, 7);
cout << " Si So: ";
cin >> a.SiSo;
cout << " Tuoi: ";
cin >> a.Tuoi;
cout << " So be trai: ";
cin >> a.Trai;
cin.ignore();
}
//ctrinh con nhap mang cau truc
void NhapMang(LopMamNon a[], int n)
{
for (int i = 0; i < n; i++)

{
cout << " NHAP THONG TIN LOP MAM NON: " << i + 1 << endl;
Nhap_o(a[i]);
cout << endl;
}
}

b) Chương trình xuất:

Để xuất danh sách các lớp mầm non, cần xây dựng 2 chương trình con gồm:
- void Xuat_o (LopMamNon a): hỗ trợ xuất ra màn hình 1 lớp mầm non đã
nhập gồm các thông tin Mã lớp, Giáo viên chủ nhiệm, Sĩ số, Tuổi, Số bé trai,
Tỷ lệ trai_gái.
- void XuatMang (LopMamNon a[], int n) : hỗ trợ xuất ra màn hình danh sách
các lớp mầm non.
//ctrinh con xuat o cau truc
void Xuat_o(LopMamNon a)
{
cout << " Ma Lop: " << a.MaLop << endl;
cout << " GVCN: " << a.GVCN << endl;
cout << " Si so: " << a.SiSo << endl;
cout << " Tuoi: " << a.Tuoi << endl;
cout << " So be trai: " << a.Trai << endl;
cout << " Ty le trai gai: " << a.Trai/(a.SiSo-a.Trai) << '\2' << endl;
}
//ctrinh con xuat mang cau truc
void XuatMang(LopMamNon a[], int n)
{
7
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
for (int i = 0; i < n; i++)
{
cout << " THONG TIN LOP MAM NON: " << i + 1;
Xuat_o(a[i]);
cout << endl;
}
}

c) Chương trình con tìm kiếm bằng LinearSearch:

Để thực hiện chức năng tìm kiếm lớp mầm non, cần xây dựng các chương trình
con, cụ thể là LinearSearch và BinarySearch, gồm:
- void LinearSearch (LopMamNon a[], int n, char x[3]): hỗ trợ tìm kiếm 1
phần tử trong mảng theo cách tìm kiếm tuyến tính, cụ thể là so sánh phần tử cần
tìm lần lượt với phần tử thứ 1, thứ 2,…của danh sách cho đến khi gặp được
phần tử cần tìm.
- void LinearSearch2(LopMamNon a[], int n, char x[3]): tương tự như
LinearSearch nhưng được cải tiến có dùng “phần tử lính canh”.
- void BinarySearch (LopMamNon a[], int n, char x[]): hỗ trợ tìm kiếm 1
phần tử trong mảng sắp xếp theo thứ tự tăng bằng cách tìm kiếm nhị phân, cụ
thể là so sánh phần tử cần tìm với phần tử ở giữa của mảng (mảng được chia
mảng ra làm 2 phần bên trái và bên phải phần tử đó). Nếu chúng không bằng
nhau, một nửa không chứa mục tiêu sẽ bị bỏ đi. Và việc tìm kiếm tiếp tục ở nửa
còn lại, một lần nữa lấy phần tử ở giữa được chọn để so sánh với phần tử cần
tìm và lặp lại điều này cho đến khi tìm thấy.
//tìm kiem tuyen tinh
int LinearSearch(LopMamNon a[], int n, char x[3])
{
for (int i = 0; i < n; i++)
{
if (strcmp(a[i].MaLop, x) == 0)
return i;
return -1;
}
}
//tim kiem tuyen tinh cach 2
int LinearSearch2(LopMamNon a[], int n, char x[3])
{
int i = 0;
strcpy_s(a[n].MaLop, x);
while (strcmp(a[i].MaLop, x) != 0)
i++;
if (i < n)
return i;
return -1;
}
//tim kiem nhi phan
int BinarySearch(LopMamNon a[], int n, char x[])
{
int left = 0;
int right = n - 1;
int mid = (left + right) / 2;
while (left <= right && strcmp(a[mid].MaLop, x) != 0)
{
if (strcmp(a[mid].MaLop, x) > 0)
right = mid - 1;
else left = mid + 1;

8
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
mid = (left + right) / 2; }
if (left > right)
return -1;
return(mid);
}

d) Chương trình con tìm kiếm bằng BinarySearch:

- void BinarySearch (LopMamNon a[], int n, char x[]): hỗ trợ tìm kiếm 1
phần tử trong mảng sắp xếp theo thứ tự tăng bằng cách tìm kiếm nhị phân, cụ
thể là so sánh phần tử cần tìm với phần tử ở giữa của mảng (mảng được chia
mảng ra làm 2 phần bên trái và bên phải phần tử đó). Nếu chúng không bằng
nhau, một nửa không chứa mục tiêu sẽ bị bỏ đi. Và việc tìm kiếm tiếp tục ở nửa
còn lại, một lần nữa lấy phần tử ở giữa được chọn để so sánh với phần tử cần
tìm và lặp lại điều này cho đến khi tìm thấy.
//tìm kiem tuyen tinh
int LinearSearch(LopMamNon a[], int n, char x[3])
{
for (int i = 0; i < n; i++)
{
if (strcmp(a[i].MaLop, x) == 0)
return i;
return -1;
}
}
//tim kiem tuyen tinh cach 2
int LinearSearch2(LopMamNon a[], int n, char x[3])
{
int i = 0;
strcpy_s(a[n].MaLop, x);
while (strcmp(a[i].MaLop, x) != 0)
i++;
if (i < n)
return i;
return -1;
}
//tim kiem nhi phan
int BinarySearch(LopMamNon a[], int n, char x[])
{
int left = 0;
int right = n - 1;
int mid = (left + right) / 2;
while (left <= right && strcmp(a[mid].MaLop, x) != 0)
{
if (strcmp(a[mid].MaLop, x) > 0)
right = mid - 1;
else left = mid + 1;
mid = (left + right) / 2; }
if (left > right)
return -1;
return(mid);
}

e) Chương trình con hoán vị (swap):

Để thực hiện thao tác hoán vị hỗ trợ cho các chương trình con sắp xếp, cần xây
dựng bổ sung thêm chương trình con hoán vị:
- void swap (LopMamNon &a, LopMamNon &b): đổi vị trí giữa 2 biến a và b.
void swap(LopMamNon& a, LopMamNon& b)

9
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
{
LopMamNon c;
c = a;
a = b;
b = c;
}

f) Chương trình con sắp xếp bằng ShakerSort:

Để thực hiện chức năng sắp xếp lớp mầm non, cần xây dựng các chương trình
con, cụ thể là thuật toán sắp xếp ShakerSort, SelectionSort, InterchangeSort,
BubbleSort, InsertionSort và thuật toán sắp xếp hiệu quả cao QuickSort,
MergeSort, gồm:
- void ShakerSort (LopMamNon a[], int n): sắp xếp danh sách lớp mầm non
theo mã lớp bằng cách đưa phần tử nhỏ/lớn nhất lên đầu dãy, sau đó lại đưa
phần tử lớn/nhỏ nhất về cuối dãy cho đến khi sắp xếp xong.
//ctrinh con Shaker Sort
void ShakerSort(LopMamNon a[], int n)
{
int left = 0;
int right = n - 1;
int k = n - 1;
while (left < right)
{
for (int i = right; i > left; i--)
if (strcmp(a[i - 1].MaLop, a[i].MaLop) > 0)
{
swap(a[i - 1], a[i]);
k = i;
}
left = k;
for (int j = left; j < right; j++)
if (strcmp(a[j].MaLop, a[j + 1].MaLop) > 0)
{
swap(a[j], a[j + 1]);
k = j;
}
right = k;
}
}
g) Chương trình con sắp xếp bằng SelectionSort:

- void SelectionSort (LopMamNon a[], int n): sắp xếp danh sách lớp mầm non
bằng cách đi tìm phần tử có giá trị nhỏ nhất trong đoạn đoạn chưa được sắp xếp
và đổi cho phần tử nhỏ nhất đó với phần tử ở đầu đoạn chưa được sắp xếp
(không phải đầu mảng) cho đến khi sắp xếp xong.
//ctrinh con Selection Sort
void SelectionSort(LopMamNon a[], int n)
{
int min;
for (int i = 0; i < n - 1; i++)
{
min = i;
for (int j = i + 1; j < n; j++)
if (strcmp(a[j].MaLop, a[min].MaLop) < 0)
min = j;
swap(a[i], a[min]);
}

10
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
}
h) Chương trình con sắp xếp bằng InterchangeSort:

- void InterchangeSort (LopMamNon a[], int n): sắp xếp danh sách lớp mầm
non bằng cách đổi chỗ liên tục phần tử ở đầu đoạn chưa được sắp xếp(không
phải đầu mảng) với phần tử nhỏ hơn nó cho tới khi duyệt tới cuối mảng, thực
hiện lặp cho tới khi mảng hoàn toàn được sắp xếp.
//ctrinh con Interchange Sort
void InterchangeSort(LopMamNon a[], int n)
{
for (int i = 0; i < n - 1; i++)
for (int j = i + 1; j < n; j++)
if (strcmp(a[i].MaLop, a[j].MaLop) > 0)
swap(a[i], a[j]);
}
i) Chương trình con sắp xếp bằng BubbleSort:

- void BubbleSort (LopMamNon a[], int n): sắp xếp dãy số bằng cách lặp lại
công việc đổi chỗ 2 số liên tiếp nhau nếu chúng đứng sai thứ tự(số sau bé hơn
số trước với trường hợp sắp xếp tăng dần) cho đến khi dãy số được sắp xếp.
//ctrinh con Bubble Sort
void BubbleSort(LopMamNon a[], int n)
{
for (int i = 0; i < n - 1; i++)
for (int j = n - 1; j > 1; j--)
if (strcmp(a[j].MaLop, a[j - 1].MaLop) < 0)
swap(a[j], a[j - 1]);
}
j) Chương trình con sắp xếp bằng InsertionSort:

- void InsertionSort (LopMamNon a[], int n): lần lượt chọn giá trị của các
phần tử trong mảng (từ giá trị thứ 2 đến giá trị cuối cùng) và so sánh với với các
giá trị phía trước vị trí của nó.Nếu tìm được vị trí phù hợp, phần tử ấy sẽ được
chèn vào vị trí thích hợp giữa các giá trị trước nhưng vẫn đảm bảo mảng được
sắp xếp theo thứ tự.
//ctrinh con Insertion Sort
void InsertionSort(LopMamNon a[], int n)
{
int vt;
LopMamNon x;
for (int i = 1; i < n; i++)
{
x = a[i];
vt = i - 1;
while ((vt >= 0) && (strcmp(a[vt].MaLop, x.MaLop) > 0))
{
a[vt + 1] = a[vt];
vt--;
}
a[vt + 1] = x; }
}

11
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
k) Chương trình con sắp xếp bằng QuickSort:

- void QuickSort (LopMamNon a[], int n): sắp xếp bằng cách chia mảng danh
sách thành 3 mảng con, chọn tùy ý một phần tử làm mốc, sau đó phát hiện và
hoán vị cặp phần tử nằm sai vị trí. Tiếp tục lặp lại cho tới khi mảng được sắp
xếp xong.
//ctrinh con Quick Sort
void QuickSort(LopMamNon a[], int left, int right)
{
int i = left, j = right;
LopMamNon x = a[(left + right) / 2];
do
{
while (strcmp(a[i].MaLop, x.MaLop) < 0) i++;
while (strcmp(a[j].MaLop, x.MaLop) > 0) j--;
if (i <= j)
{
swap(a[i], a[j]);
i++;
j--;
}
} while (i < j);
if (left < j) QuickSort(a, left, j);
if (i < right) QuickSort(a, i, right);
}

l) Chương trình con sắp xếp bằng MergeSort:

- void Mergesort (LopMamNon a[], int n): Thuật toán này chia mảng danh
sách thành 2 nửa. Tiếp tục lặp lại việc này ở các nửa mảng đã chia. Sau cùng
gộp các nửa đó thành mảng đã sắp xếp. Thuật toán này cần có thêm hai hàm
khác hỗ trợ, gồm:
+ void Distribute (LopMamNon a[], int n, int &nb, int &nc, int k): Phân
phối đều luân phiên các dãy con độ dài k từ mảng a vào hai mảng con b và c.
+ void Merge (LopMamNon a[], int nc, int nb, int k): Trộn mảng b và mảng
c vào mảng a
//distribute hỗ trợ mergesort
void Distribute(LopMamNon a[], int n, int& nb, int& nc, int k)
{
int i, pa, pb, pc;
pa = pb = pc = 0;
while (pa < n)
{
for (i = 0; (pa < n) && (i < k); i++, pa++, pb++)
b[pb] = a[pa];
for (i = 0; (pa < n) && (i < k); i++, pa++, pc++)
c[pc] = a[pa];
}
nb = pb;
nc = pc;
}
//merge hỗ trợ mergesort
void Merge(LopMamNon a[], int nb, int nc, int k)
{
int p, pb, pc, ib, ic, kb, kc;
p = pb = pc = 0; ib = ic = 0;
while ((nb > 0) && (nc > 0))
12
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
{
kb = min(k, nb);
kc = min(k, nc);
if (strcmp(b[pb + ib].MaLop, c[pc + ic].MaLop) <= 0)
{
a[p++] = b[pb + ib];
ib++;
if (ib == kb)
{
for (; ic < kc; ic++)
a[p++] = c[pc + ic];
pb += kb;
pc += kc;
ib = ic = 0;
nb -= kb;
nc -= kc;
}
}
else
{
a[p++] = c[pc + ic];
ic++;
if (ic == kc)
{
for (; ib < kb; ib++)
a[p++] = b[pb + ib];
pb += kb;
pc += kc;
ib = ic = 0;
nb -= kb;
nc -= kc;
}
}
}
}
//ctrinh con mergesort
void MergeSort(LopMamNon a[], int n)
{
int k, nc = 0, nb = 0;
for (k = 1; k < n; k *= 2)
{
Distribute(a, n, nb, nc, k);
Merge(a, nb, nc, k);
}

m) Kiểm tra: (hàm main kiểm tra chương trình con)

Hàm main kiểm tra chương trình con tìm kiếm:
//ham chinh
int main()
{
const int spt = 5;
LopMamNon a[spt];
char x[10];
NhapMang(a, spt);
XuatMang(a, spt);
cout << " Nhap ma lop can tim: ";
cin.getline(x, 11);
int i = LinearSearch(a, spt, x);
/*int i = LinearSearch2(a, spt, x);*/
/*int i = BinarySearch(a, spt, x);*/
if (i == -1)
13
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
{
cout << " Khong co lop nay";
}
else
{
cout << " Lop can tim la: ";
Xuat_o(a[i]);
}
cout << "\nSap xep lai danh sach lop mam non theo thu tu ma lop:\t " << endl;
//Kiem tra Shaker Sort
/*ShakerSort(a, spt);
cout << "\nDanh sach sap xep ShakerSort: " << endl;
XuatMang(a, spt);
cout << endl;*/

//Kiem tra Selection Sort

/*SelectionSort(a, spt);
cout << "\nDanh sach sap xep SelectionSort: " << endl;
XuatMang(a, spt);
cout << endl;*/

//Kiem tra Interchange Sort

/*InterchangeSort(a, spt);
cout << "Danh sach sap xep InterchangeSort: " << endl;
XuatMang(a, spt);
cout << endl;*/

//Kiem tra Bubble Sort

/*BubbleSort(a, spt);
cout << "Danh sach sap xep BubbleSort: " << endl;
XuatMang(a, spt);
cout << endl;*/

//Kiem tra Insertion Sort

/*InsertionSort(a, spt);
cout << "Danh sach sap xep InsertionSort: " << endl;
XuatMang(a, spt);
cout << endl;*/

//Kiem tra Quick Sort

QuickSort(a, 0, 5);
cout << "Danh sach sap xep QuickSort: " << endl;
XuatMang(a, spt);
cout << endl;

//Kiem tra MergeSort

/*MergeSort(a, spt);
cout << "Danh sach sau khi sap xep MergeSort: " << endl;
XuatMang(a, spt);
cout << endl;*/

return 0;
}

14
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
2. Kết quả chạy:

Hình 2. 1 Kết quả test chương trình con nhập mảng

Hình 2. 2 Kết quả test chương trình con xuất mảng

15
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

Hình 2. 3 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử đầu mảng)

Hình 2. 4 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử giữa mảng)

Hình 2. 5 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử cuối mảng)

Hình 2. 6 Kết quả test chương trình con tìm kiếm (không tìm thấy)

Các hàm tìm kiếm LinearSearch, LinearSearch2 và BinarySearch khi test cho ra
kết quả như nhau.

16
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

Hình 2. 7 Kết quả test chương trình con ShakerSort

Hình 2. 8 Kết quả chạy chương trình con SelectionSort

17
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

Hình 2. 9 Kết quả chạy chương trình con InterchangeSort

Hình 2. 10 Kết quả chạy chương trình con BubbleSort

18
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

Hình 2. 11 Kết quả chạy chương trình con InsertionSort

Hình 2. 12 Kết quả chạy chương trình con QuickSort

19
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

Hình 2. 13 Kết quả chạy chương trình con MergeSort

20
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

CHƯƠNG 3. CHỨC NĂNG TRÊN DANH SÁCH LIÊN KẾT

LINKED LIST
1. Chức năng trên danh sách liên kết
a) Chương trình con khởi tạo danh sách liên kết:
Khởi tạo danh sách liên kết bằng các chương trình con sau:
// khai bao cau truc Node
typedef struct lmnNode
{
lmnType tt;
struct lmnNode* next;
} lmnNodeType;

//khai bao cau truc danh sach lien ket

typedef struct
{
lmnNodeType* head;
lmnNodeType* tail;
} lmnLList;

//khoi tao danh sach

void Init_dslmn_LList(lmnLList* l)
{
l->head = NULL;
l->tail = NULL;
}

//tao Node tu o bu da duoc nhap

lmnNodeType* get_lmnNode(lmnType x)
{
lmnNodeType* p;
p = new lmnNodeType;
p->tt = x;
p->next = NULL;
return p;
}

b) Chương trình con nhập danh sách liên kết:

Để nhập danh sách liên kết các lớp mầm non, cần xây dựng 2 chương trình con
gồm:
- void nhaplmn(lmnType& lmn): hỗ trợ nhập 1 lớp mầm non gồm các thông tin
Mã lớp, Giáo viên chủ nhiệm, Sĩ số, Tuổi, Số bé trai, Tỷ lệ trai_gái.
- void addfirst(lmnLList* l, lmnNodeType* n): hỗ trợ chèn phần tử vào đầu
danh sách
//nhap thong tin 1 lop mam non
void nhaplmn(lmnType& lmn)
{
cout << " Ma Lop: ";
cin.getline(lmn.MaLop, 10);
cout << " GVCN: ";
cin.getline(lmn.GVCN, 7);
cout << " Si So: ";
cin >> lmn.SiSo;
cout << " Tuoi: ";
cin >> lmn.Tuoi;
cout << " So be trai: ";
cin >> lmn.Trai;
21
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
cin.ignore();

}//them phan tu vao dau danh sach

void addfirst(lmnLList* l, lmnNodeType* n)
{
if (l->head == NULL)
{
l->head = n;
l->tail = n;
}
else
{
n->next = l->head;
l->head = n;
}
}

c) Chương trình con xuất danh sách liên kết:

Để xuất danh sách các lớp mầm non, cần xây dựng 3 chương trình con gồm:
- void xuatlmn(lmnType lmn): hỗ trợ xuất ra màn hình 1 lớp mầm non đã nhập
gồm các thông tin Mã lớp, Giáo viên chủ nhiệm, Sĩ số, Tuổi, Số bé trai, Tỷ lệ
trai_gái.
- void print_lmnNode(lmnNodeType* n): hỗ trợ xuất ra màn hình 1 Node.
- void Print_List(lmnLList* l): hỗ trợ xuất ra màn hình danh sách liên kết chứa
thông tin các lớp mầm non.
//xuat thong tin 1 lop mam non
void xuatlmn(lmnType lmn)
{
cout << " Ma Lop: " << lmn.MaLop << endl;
cout << " GVCN: " << lmn.GVCN << endl;
cout << " Si so: " << lmn.SiSo << endl;
cout << " Tuoi: " << lmn.Tuoi << endl;
cout << " So be trai: " << lmn.Trai << endl;
cout << " Ty le trai gai: " << lmn.Trai / (lmn.SiSo - lmn.Trai) << '\
2'<< endl;
}

//in Node ra man hinh

void print_lmnNode(lmnNodeType* n)
{
xuatlmn(n->tt);
}

//in danh sach lien ket

void Print_List(lmnLList* l)
{
lmnNodeType* p;
p = l->head;
while (p != NULL)
{
xuatlmn(p->tt);
p = p->next;
}
}

d) Chương trình con tìm kiếm LinearSearch:

Để thực hiện chức năng tìm kiếm lớp mầm non, cần xây dựng chương trình con
LinearSearch:

22
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
- lmnNodeType* LinearSearch(lmnLList* l, char ma[]): hỗ trợ tìm kiếm 1
phần tử trong mảng theo cách tìm kiếm tuyến tính, cụ thể là so sánh phần tử cần
tìm lần lượt với phần tử thứ 1, thứ 2,…của danh sách cho đến khi gặp được
phần tử cần tìm.
//tim kiem 1 lop mam non
lmnNodeType* LinearSearch(lmnLList* l, char ma[])
{
lmnNodeType* p;
p = l->head;
while (p != NULL && strcmp(p->tt.MaLop, ma) != 0)
p = p->next;
return p;
}

e) Chương trình con hoán vị (swap):

Để thực hiện thao tác hoán vị hỗ trợ cho các chương trình con sắp xếp, cần xây
dựng bổ sung thêm chương trình con hoán vị:
- void swap(lmnNodeType& a, lmnNodeType& b): đổi vị trí giữa 2 phần tử a
và b.
void swap(lmnNodeType& a, lmnNodeType& b)
{
lmnNodeType t = a;
a = b;
b = t;

}
Để thực hiện chức năng sắp xếp lớp mầm non, cần xây dựng các chương trình
con, cụ thể là thuật toán sắp xếp SelectionSort, InterchangeSort, BubbleSort và
InsertionSort, gồm:
f) Chương trình con sắp xếp bằng InsertSort:

- void Insert_Sorted(lmnLList* l, lmnNodeType* n): hàm hỗ trợ cho chương

trình con InsertionSort, dùng để chèn 1 phần tử vào danh sách liên kết đã được
sắp xếp
void Insert_Sorted(lmnLList* l, lmnNodeType* n)
{
lmnNodeType* p;
p = l->head;

//kiem tra danh sach rong hoac phai chen ngay tu dau
if (p == NULL || strcmp(p->tt.MaLop, n->tt.MaLop) > 0)
addfirst(l, n);
else
{
//do vi tri chen
while (p->next != NULL && strcmp(p->next->tt.MaLop, n->tt.MaLop) < 0)
p = p->next;
//chen
n->next = p->next;
p->next = n;
}
}
23
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
- void InsertionSort(lmnLList* l): lần lượt chọn giá trị của các phần tử trong
mảng (từ giá trị thứ 2 đến giá trị cuối cùng) và so sánh với với các giá trị phía
trước vị trí của nó.Nếu tìm được vị trí phù hợp, phần tử ấy sẽ được chèn vào vị
trí thích hợp giữa các giá trị trước nhưng vẫn đảm bảo mảng được sắp xếp theo
thứ tự.
void InsertionSort(lmnLList* l)
{
lmnLList* res;
res = new lmnLList;
Init_dslmn_LList(res);
lmnNodeType* p, * q;
p = l->head;
while (p != NULL)
{
//tro q giu phan DSLK sau truoc khi dua phan tu vao dau res
q = p->next;
p->next = NULL;
Insert_Sorted(res, p);
p = q;
}
l->head = res->head;
l->tail = res->tail;
}
g) Chương trình con sắp xếp bằng SelectionSort:

- void SelectionSort(lmnLList* l): sắp xếp danh sách lớp mầm non bằng cách
đi tìm phần tử có giá trị nhỏ nhất trong đoạn đoạn chưa được sắp xếp và đổi cho
phần tử nhỏ nhất đó với phần tử ở đầu đoạn chưa được sắp xếp (không phải đầu
mảng) cho đến khi sắp xếp xong.
void SelectionSort(lmnLList* l)
{
lmnNodeType* p, * q, * min;
//con tro p dung duyet qua danh sach lien ket
//con tro q dung phoi hop tim min
for (p = l->head; p != l->tail; p = p->next)
{
//tim min
min = p;
for (q = p->next; q != NULL; q = q->next)
if (strcmp(q->tt.MaLop, min->tt.MaLop) < 0)
min = q;
//hoan vi de du min ve dung vi tri
swap(min->tt, p->tt);
}
}
h) Chương trình con sắp xếp bằng InterchangeSort:

- void InterchangeSort(lmnLList* l): sắp xếp danh sách lớp mầm non bằng
cách đổi chỗ liên tục phần tử ở đầu đoạn chưa được sắp xếp(không phải đầu
mảng) với phần tử nhỏ hơn nó cho tới khi duyệt tới cuối mảng, thực hiện lặp
cho tới khi mảng hoàn toàn được sắp xếp.
void InterchangeSort(lmnLList* l)
{
lmnNodeType* p, * q;
for (p = l->head; p != l->tail; p = p->next)
24
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
for (q = p->next; q != NULL; q = q->next)
if (strcmp(p->tt.MaLop, q->tt.MaLop) > 0)
swap(p->tt, q->tt);

i) Chương trình con sắp xếp bằng BubbleSort:

- void BubbleSort (LopMamNon a[], int n): sắp xếp dãy số bằng cách lặp lại
công việc đổi chỗ 2 số liên tiếp nhau nếu chúng đứng sai thứ tự(số sau bé hơn
số trước với trường hợp sắp xếp tăng dần) cho đến khi dãy số được sắp xếp.
void BubbleSort(lmnLList* l)
{
lmnNodeType* p, * q;
for (p = l->head; p != l->tail; p = p->next)
{
for (q = l->head; q != l->tail;q = q->next)
if (strcmp(q->tt.MaLop, q->next->tt.MaLop) > 0)
{
swap(q->tt.MaLop, q->next->tt.MaLop);
}
}
}
j) Kiểm tra: (hàm main kiểm tra chương trình con)
int main()
{
//tao danh sach
lmnLList* ds;
ds = new lmnLList;
Init_dslmn_LList(ds);
char MaLop[5];

lmnType x;
lmnNodeType* p;
char t = 'c';

//tao vong lap nhap tt lop mam non, ket thuc khi nhap xong
while (t == 'c' || t == 'C')
{
//nhap tt
lmnType lmn;
cout << "Nhap thong tin lop mam non:" << endl;
nhaplmn(lmn);

//tao node
lmnNodeType* n;
n = new lmnNodeType;
n = get_lmnNode(lmn);

//dua vao danh sach

addfirst(ds, n);

//hoi con muon nhap nua hay ko

cout << "Nhap tiep ? (C/K): ";
cin >> t;
cin.ignore();
}

//in danh sach

cout << "\nDANH SACH LOP MAM NON" << endl;
Print_List(ds);

25
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
system("pause");

//tim kiem
cout << "Nhap ma lop can tim: " << endl;
cin.getline(MaLop, 5);
lmnNodeType* res = LinearSearch(ds, MaLop);
cout << "\nKet qua tim kiem: " << endl;
if (res == NULL)
cout << "Khong tim thay lop nay!!!" << endl;
else
print_lmnNode(res);
cout << endl;
system("pause");
//sap xep DSLK theo thu tu bang InsertionSort
cout << "Sap xep theo InsertionSort" << endl;

x = { "02", "B", 12, 4, 6 }; InsertionSort(ds);

x = { "05", "E", 12, 4, 6 }; InsertionSort(ds);
x = { "01", "A", 10, 5, 4 }; InsertionSort(ds);
x = { "03", "C", 14, 3, 10 }; InsertionSort(ds);
x = { "04", "D", 10, 3, 6 }; InsertionSort(ds);
Print_List(ds);

//sap xep DSLK theo thu tu bang SelectionSort

cout << "\nSap xep theo
x = { "02", "B", 12, 4,
x = { "05", "E", 12, 4,
x = { "01", "A", 10, 5,
x = { "03", "C", 14, 3,
x = { "04", "D", 10, 3,
Print_List(ds);
SelectionSort" << endl;
6 }; SelectionSort(ds);
6 }; SelectionSort(ds);
4 }; SelectionSort(ds);
10 }; SelectionSort(ds);
6 }; SelectionSort(ds);

//sap xep DSLK theo thu tu bang InterchangeSort

cout << "\nSap xep theo
x = { "02", "B", 12, 4,
x = { "05", "E", 12, 4,
x = { "01", "A", 10, 5,
x = { "03", "C", 14, 3,
x = { "04", "D", 10, 3,
Print_List(ds);
InterchangeSort" << endl;
6 }; InterchangeSort(ds);
6 }; InterchangeSort(ds);
4 }; InterchangeSort(ds);
10 }; InterchangeSort(ds);
6 }; InterchangeSort(ds);

//sap xep DSLK theo thu tu bang BubbleSort

x = { "02", "B", 12, 4,
x = { "05", "E", 12, 4,
x = { "01", "A", 10, 5,
x = { "03", "C", 14, 3,
x = { "04", "D", 10, 3,
cout << "\nSap xep theo
Print_List(ds);
6 }; BubbleSort(ds);
6 }; BubbleSort(ds);
4 }; BubbleSort(ds);
10 }; BubbleSort(ds);
6 }; BubbleSort(ds);
BubbleSort" << endl;

system("pause");
return 0;
}

26
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
2. Kết quả chạy:

Hình 3. 1 Kết quả thử chức năng nhập danh sách liên kết

Hình 3. 2 Kết quả thử chức năng xuất danh sách liên kết

Hình 3. 3 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử đầu mảng)

27
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

Hình 3. 4 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử giữa mảng)

Hình 3. 5 Kết quả test chương trình con tìm kiếm (tìm thấy phần tử cuối mảng)

Hình 3. 6 Kết quả test chương trình con tìm kiếm (không tìm thấy)

Hình 3. 7 Kết quả chạy chương trình con InsertionSort

28
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

Hình 3. 8 Kết quả chạy chương trình con SelectionSort

Hình 3. 9 Kết quả chạy chương trình con InterchangeSort

29
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

Hình 3. 10 Kết quả chạy chương trình con BubbleSort

CHƯƠNG 4. KẾT LUẬN

1. Các chức năng đã thực hiện:
a) Các chức năng đã thực hiện trong mảng cấu trúc Array:
- Nhập danh sách các lớp
- Xuất danh sách các lớp
- Tìm thông tin lớp theo mã lớp bằng :
+ LinearSearch
+ BinarySearch
- Sắp xếp danh sách các lớp mầm non theo thứ tự mã lớp bằng :
+ ShakerSort
+ InterchangeSort
+ InsertionSort
+ SelectionSort
+ BubbleSort
+ QuickSort
+ MergeSort
b) Các chức năng đã thực hiện trong mảng cấu trúc Array:
- Khai báo danh sách liên kết
- Nhập danh sách các lớp
- Xuất danh sách các lớp
- Tìm thông tin lớp theo mã lớp bằng :
+ LinearSearch
30
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như
- Sắp xếp danh sách các lớp mầm non theo thứ tự mã lớp bằng :
+ InterchangeSort
+ InsertionSort
+ SelectionSort
+ BubbleSort
2. Các chức năng chưa thực hiện (không có)

31
Báo cáo CTDL&GT _Nguyễn Ngọc Quỳnh Như

32