TRƯỜNG ĐẠI HỌC GIAO THÔNG VẬN TẢI

PHÂN HIỆU TẠI TP. HỒ CHÍ MINH

BỘ MÔN CẤU TRÚC DỮ LIỆU

BÁO CÁO BÀI TẬP LỚN

ĐỀ TÀI : QUẢN LÝ THƯ VIỆN

Giảng viên hướng dẫn: TRẦN THỊ DUNG

Sinh viên thực hiện: NGUYỄN THANH HƯNG

Lớp : KTĐT-VT

Khoá : 62

Tp. Hồ Chí Minh, năm 2022

 MỤC LỤC (size 15, bold)

(Cách 1 tab, Time newRoman, 20)

BẮT BUỘC DÙNG MỤC LỤC TỰ ĐỘNG

CHƯƠNG 1: TỔNG QUAN ………………………………………..…….………… 1

1.1. Tổng quan về nợ công…………………………………………………..……....... 1

1.1.1. Nợ công Việt Nam …………………………………………………………..… 2
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
 DANH MỤC CHỮ VIẾT TẮT
STT Mô tả Ý nghĩa Ghi chú

BẢNG BIỂU, SƠ ĐỒ, HÌNH VẼ (size 15, bold)

(Cách 1 tab, Time newRoman, 20, mỗi nội dung trình bày bắt đầu từ 1 trang mới)

Bảng 1.1: (size 13)…………………………………………………………………........

Bảng 1.2: ..........................................................................................................................

Sơ đồ 1.1:………………………………………………………………………………..

Hình 1.1: ………………………………………………………………………………..

Ghi chú:

- Xếp sau trang Mục lục

- Chữ số thứ nhất chỉ tên chương
- Chữ số thứ hai chỉ thứ tự bảng biểu, sơ đồ, hình,…trong mỗi chương
- Ở cuối mỗi bảng biểu, sơ đồ, hình,…trong mỗi chương phải có ghi chú, giải
thích, nêu rõ nguồn trích hoặc sao chụp,…
 CHƯƠNG 1. MỞ ĐẦU

I. Mục đích môn học

1. Môn học cung cấp những kiến thức cơ bản, nền tảng về một số cấu trúc dữ
liệu và một số thuật tóan. Nó là cơ sở để xây dựng các hệ thống phần mềm
lớn và phức tạp. 
2. Môn học giúp sinh viên hiểu cách thức tổ chức lưu trữ dữ liệu trong bộ nhớ
của máy tính và làm thế nào để sử dụng nó một cách có hiệu quả trong các
chương trình. Sử dụng những kiến thức này để xây dựng các cấu trúc dữ liệu
phù hợp cho các hệ thống phức tạp khác.
3. Cung cấp cho sinh viên một số thuật toán cơ bản trên các cấu trúc dữ liệu
4. Sinh viên hiểu và biết phân tích thời gian, không gian (bộ nhớ) cần cho một
thuật toán.
III. Các đối tượng nghiên cứu trong môn học
 Các cấu trúc dữ liệu chuẩn
• Vectors, lists, stack, queue,trees, graphs,…
 Các thuật toán chuẩn
• Sắp xếp (Sorting)
• Tìm kiếm (Selection)
 Phân tích độ phức tạp về thời gian và không gian (bộ nhớ) của các thuật
toán.
 Những kỹ năng lựa chọn thuật toán, cấu trúc dữ liệu và cài đặt thuật
toán
IV. Các kiến thức bổ trợ cho môn học
 Ngôn ngữ lập trình C++
 Phương pháp lập trình hướng đối tượng (Object Oriented Programming
method- OOP)
V. Tài liệu tham khảo
1. Data structures and Algorithms in C++ - Michael T. Goodrich, Roberto
Tamassia
2. Introduction to Algorithms - Thomas H. Cormen, Charles E. Leiserson,
Ronald L. Revest, Clifford Stein,, MIT Press
3. Thuật toán và lập trình - Lê Minh Hoàng, ĐH Sư phạm Hà Nội
4. Cấu trúc dữ liệu và giải thuật – Nguyễn Văn Long, NXB GTVT
5. Cấu trúc dữ liệu và giải thuật – Đỗ Xuân Lôi, NXB Khoa học kỹ thuật
6. Cẩm nang thuật toán (vol1 + vol2), Robert Sedgewick, NXB KHKT
7. Lập trình hướng đối tượng và C++, Phạm Văn Ất, NXB GTVT
VI. Một số mục tiêu của công nghệ phần mềm
 Tin cậy và chính xác (Reliability – correctness)
 Hữu dụng (utility)
o Đạt được những gì mong muốn
o Đáp ứng đúng thời điểm
 Mềm dẻo (flexibility)
o Có khả năng mang chuyển được (Portability), tức là có
thể dễ dàng mang cài đặt sang một hệ thống khác.
o Khả năng tương thích
- Dễ bảo trì
- Dễ hiểu
- Có thể sử dụng lại
 Hiệu quả (efficiency)
o Người lập trình (không mất quá nhiều công sức cho
việc lập trình)
o Máy
 Thời gian
 Bộ nhớ

VII. Các nguyên lý của CNPM

 Trừu tượng (Abstract): Chắt lọc một hệ thống phức tạp xuống những phần
cơ bản nhất của nó và mô tả những phần này bằng một ngôn ngữ đơn giản,
chính xác
 Modul hóa (Modularity): Hạn chế độ phức tạp bằng cách phân chia ra thành
nhiều phần (Chia để trị).
  Mô-đun đề cập đến một nguyên tắc tổ chức mã trong đó các thành
phần khác nhau của hệ thống phần mềm được chia thành các đơn vị
chức năng riêng biệt
 Đóng gói (Encapsulation):
 Các thành phần khác nhau của một hệ thống phần mềm không được
tiết lộ các chi tiết bên trong của chúng

Bài 2. Ngôn ngữ lập trình C++

I. Giới thiệu
 Ngôn ngữ lập trình C++ là ngôn ngữ được phát triển dựa trên ngôn
ngữ lập trình C.
 Do đó về cơ bản, cú pháp của C++ giống với cú pháp của C. Tuy
nhiên nó có một số mở rộng sau đây:
- Nhập, xuất dữ liệu (cout, cin)
- Hàm có đối mặc định, hàm có đối tham chiếu
- Nạp chồng hàm (hay tải bội hàm – overload function)
- Hàm mẫu
- Lớp (có khả năng xây dựng các chương trình HĐT)

Thiết lập biên dịch C++11 cho dev C++

• Tools-> Compiler option -> General
• Check vào box
Add the following commands when calling
the compiler
• Soạn vào
–std=c++11
II. Nhập xuất dữ liệu
• Nhập dữ liêu kiểu số
cin>>Tênbiến1>>Tênbiến2>>…>>Tênbiếnn;
Ví dụ:
float x,y;
int m, n;
cin>>x>>y;
cin>>m;
cin>>n;
• Nhập dữ liệu kiểu xâu ký tự
cin.ignore(1);
cin.get(Tênbiến, n); //n là số ký tự tối đa cần gán
cho biến
Ví dụ:
char ht[30];
char w[10];
cin.ignore(1);
cin.get(ht, 30);
cin.ignore(1);
cin.get(w, 5);
• Xuất dữ liệu
cout<<Bthức1<<Bthức2<<…<<Bthứcn;
Ví dụ:
#include”iostream.h”
void main()
{
float x, y=10;
cout<<“Nhap x=“;
cin>>x;
cout<<“x+y=“<<x+y;
cout<<“x-y=“<<x-y;
}
II. Hàm
• Khi xây dựng các hàm ngoài các kiểu hàm như trong C thì C++ còn
cho phép xây dựng các kiểu hàm sau đây:
• Đối tham chiếu
• Đối mặc định
• Nạp chồng hàm (overload function)
• Hàm mẫu (template)
• Hàm có đối tham chiếu
 - - Khai báo hàm:
- DataType Func_Name(DataType & Arg_Nam,..);
- Sử dụng hàm: Các đối thực sự tương ứng với đối tham chiếu phải là
các biến cùng kiểu với kiểu của đối.
- Sự hoạt động của hàm như hàm có đối con trỏ
- Ví dụ: Xây dựng hàm hoán đổi giá trị của hai biến
void hoandoi(float &a, float void main(){
&b)
float x, y;
{
cout<<“ Nhap x, y: ”;
float tg;
cin>>x>>y;
tg = a;
cout<< “x = “<< x <<“ y =
a = b;
“<<y;
b = tg;
hoandoi(x,y);
}
cout<< “x = “<< x <<“ y =
“<<y;
getch(); }
#include <iostream.h>
#include <conio.h>
void duplicate (int& a, int& b, int& c)
{ a = 2; b = 2; c = 2; }
int main (){
int x=1, y=3, z=7;
duplicate (x, y, z);
cout << "x=" << x << ", y=" << y << ", z=" << z;
return 0;
}

- CẤU TRÚC DANH SÁCH

I. Khái niệm danh sách
  Là cấu trúc dữ liệu tuyến tính, trong đó các phần tử dữ liệu đượcsắp xếp
theo một thứ tự xác định
 Là một tập sắp thứ tự các phần tử cùng một kiểu
 Ví dụ
o Danh sách sinh viên
o Danh sách điện thoại
o Danh sách môn học
o Danh sách bài hát
o Danh sách công việc
II. Trừu tượng hóa danh sách
• Đặc tả dữ liệu
• Tất cả các phần tử của danh sách sắp theo thứ tự nào đó.
• Đặc tả các phép toán
1. Khởi tạo/xóa danh sách
2. Kiểm tra danh sách rỗng/đầy
3. Đếm số phần tử có trong danh sách
4. Truy xuất một phần tử trong danh sách theo vị trí
5. Thêm/xóa/thay thế một phần tử
6. Duyệt tất cả các nút
• Đặc tả dữ liệu
A = (a0, a1, …, an), trong đó ai là phần tử thứ i của danh sách A. Ví dụ:
A = (1, 2, 3, 4, 5)
A = (‘Toán’, ‘Lý’, ‘Hóa’, ‘Văn’, ‘Anh’)
• Đặc tả các phép toán
1. Khởi tạo/xóa danh sách: init(A)
2. Kiểm tra danh sách rỗng/đầy: isEmpty(A) / isFull(A)
3. Đếm số phần tử có trong danh sách: length(A)
4. Truy xuất một phần tử trong danh sách theo vị trí: retrieve(A, i)
5. Thêm phần tử x vào vị trí i trong danh sách: insert(A, i, x)
 6. Thêm phần tử x vào đuôi danh sách: append(A, x)
7. Xóa phần tử ở vị trí i trong danh sách: remove(A, i)
8. Thay thế phần tử ở vị trí i trong danh sách: replace(A, i, x)
Cài đặt danh sách bằng mảng
Mảng (array)
• Tập hợp các phần tử (các biến) có cùng một kiểu.
• Một phần tử cụ thể trong mảng sẽ được xác định và truy cập bởi một chỉ số.
• Trong C/C++, các phần tử của mảng được đặt cạnh nhau tạo thành một khối
liên tục. Địa chỉ thấp nhất tương ứng với phần tử đầu tiên, địa chỉ cao nhất
tương ứng với phần tử cuối cùng.
• Mảng thì có thể là một chiều hoặc nhiều chiều.
• Mảng một chiều tĩnh:
• int A[100];
• phanso dayphanso[1000];
• Mảng một chiều động:
• int *A = new int[100];
• phanso *dayphanso = new phanso[1000];
•

Cài đặt hàm

 Cài đặt danh sách bằng mảng động

Hàm insert, append của Dlist

• Khi mảng đầy
• Cấp phát động một mảng mới có cỡ gấp đôi mảng cũ
• Chép đoạn đầu của mảng cũ sang mảng mới
• Đưa phần tử cần xen vào mảng mới
• Chép đoạn còn lại của mảng cũ sang mảng mới
• Hủy mảng cũ
• Cập nhật size, last
• Ví dụ:
• A = (1, 3, 4, 8); size = 4; last = 3
• insert(A, 3, 50)
Danh sách liên kết
Độ phức tạp khi cài đặt danh sách bằng mảng
• Truy cập phần tử
• Cập nhật?
• Chèn phần tử?
• Xóa phần tử?
Danh sách liên kết
• Là tập dữ liệu tuần tự mà mỗi phần tử chứa vị trí của phần tử tiếp theo.
• Cấp phát động lúc chạy chương trình
• Các phần tử nằm rải rác ở nhiều nơi trong bộ nhớ
• Kích thước danh sách chỉ bị giới hạn do RAM
• Thao tác thêm xoá đơn giản
• DSLK đơn, DSLK kép, DSLK vòng.

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

Khái niệm DSLK đơn
• DSLK đơn là một danh sách các nút,
• Mỗi nút gồm 2 thành phần:
• Phần chứa dữ liệu – data
• Phần chỉ vị trí (địa chỉ) của phần tử tiếp theo trong danh sách –Phần
next là con trỏ, trỏ đến nút kế tiếp
 Danh sách liên kết đơn bằng C++
• Mỗi nút là một biến Node.
• Nút cuối cùng có giá trị next bằng NULL.
• Xác định DSLK bằng địa chỉ của nút đầu tiên
trong danh sách.
• Gọi biến lưu địa chỉ này là con trỏ đầu head
• Khởi tạo danh sách rỗng: Node *head = NULL;
data next

• Có thể sử dụng thêm con trỏ đuôi tail để các thao tác trên DSLK được thuận
lợi
• Danh sách rỗng: head = tail = NULL;

CẤU TRÚC NGĂN XẾP (STACK)

Stack là gì?
• Stack là một danh sách đặc biệt mà việc thêm vào và loại bỏ được thực hiện
tại một đầu (gọi là đỉnh – top của stack).
• Hoạt động theo cơ chế LIFO (Last In First Out)
Phương pháp cài đặt
Khai báo
struct node
{
DataType data; node *next;
 };
typedef node* stack;
Các thao tác trên stack
• Khởi tạo: init
• Kiểm tra rỗng: isEmpty
• Thêm một phần tử vào stack: push
• Lấy một phần tử ra khỏi stack: pop
• Xem nội dung của phần tử đầu tiên trong stack: peek
Thêm phần tử x vào stack- push
• Tạo nút mới có dữ liệu là x
• Thêm nút vừa tạo vào đầu stack

// khai bao cau truc stack struct node

{
int data; node *next;
};
typedef node* stack;
void push(stack &s, int x)
{
node* p = new node; p->data = x;
p->next = s; s = p;
}
Lấy một phần tử ra khỏi stack – pop
• Lấy ra phần tử đầu danh sách
• Trả về nội dung và giải phóng nút
Trung tố, tiền tố, và hậu tố
• Trung tố (infix), hậu tố (postfix, ký pháp Ba Lan ngược), tiền tố (prefix, ký
pháp Ba Lan) là các cách biểu diễn khác nhau của biểu thức toán học.
• Trung tố: cách biểu diễn thông dụng
• Toán tử được viết giữa các toán hạng.
• Phép toán có thứ tự ưu tiên.
• Thứ tự thực hiện phép toán từ trái qua phải nếu phép toán có cùng thứ
tự ưu tiên.
• Sử dụng dấu ngoặc đơn () để thay đổi thứ tự thực hiện của
phép toán.
• Ví dụ: A * (B + C) / D
• Tiền tố (Ký pháp Ba Lan)
• Toán tử được viết trước toán hạng.
• Thứ tự thực hiện phép toán từ trái qua phải.
• Không sử dụng dấu ngoặc đơn () để thay đổi thứ tự thực hiện của
phép toán.
• Phép toán được thực hiện trên các toán hạng nằm ngay sau
phép toán.
• Ví dụ: / * A + B C D
• Hậu tố (Ký pháp Ba Lan ngược)
• Toán tử được viết sau các toán hạng.
• Thứ tự thực hiện phép toán từ trái qua phải
• Không sử dụng dấu ngoặc đơn () để thay đổi thứ tự thực hiện của
phép toán.
• Phép toán được thực hiện trên các toán hạng nằm ngay trước
phép toán.
• Ví dụ: A B C + * D /
Một số ví dụ
• a / (b – c + d) * (e – a) * c
 • a/b–c+d*e–a*c
• a+b*c–d/e*f
• (a + b * c – d) / (e * f)
• (7 / (5 – 3) * 9 + 2)
Chương 6: Các thuật toán sắp xếp (SORTING)
Bài toán
 Input:
 Dãy các phần tử (và một thứ tự)
 (Dãy các phần tử thường được lưu bằng mảng.)
 Output:
 Dãy các phần tử được sắp theo thứ tự tăng hoặc giảm dần theo một
hoặc một vài thuộc tính của nó (các thuộc tính này gọi là thuộc tính
khóa).
 Thuộc tính khóa được sắp xếp theo một hàm logic, ví dụ (<=) hoặc các
toán tử so sánh khác.
Các thuật toán với thời gian chạy O(n2)
 Nổi bọt – Bubble sort
 Chèn – Insertion sort
 Chọn – Selection sort
Sắp xếp nổi bọt – Bubble sort
Ý tưởng: Thực hiện chuyển dần các phần tử có giá trị khóa lớn về cuối
dãy, các phần tử có khóa bé về đầu dãy.
Thuật toán
 - Trong đó swap là thủ tục tráo đổi vị trí của hai phần tử
void Swap(object &a, object &b){
Object tg;
tg = a; a = b; b = tg;
}
Sắp xếp chọn - Selection sort
• Ý tưởng: Chọn phần tử có khóa nhỏ nhất trong các phần tử còn lại chuyển
nó về đầu và loại bỏ nó khỏi dãy.

PHẦN II: Chương tình quản lý thư viện bằng ngôn ngữ C++
 Sắp xếp chèn – Insertion sort

Chia và trị - Divide and conquer

 Chia và trị là phương pháp thiết kế thuật toán theo kiểu:
 Phân chia: Chia dữ liệu đầu vào S của bài toán thành 2 tập con rời
nhau S1 và S2
 Đệ qui: Giải bài toán với dữ liệu vào là các tập con S1 và S2
 Trị: kết hợp các kết quả của S1 và S2 thành kết quả của S
 Trường hợp cơ sở cho thuật toán đệ qui ở đây là các bài toán có kích thước 0
hoặc 1
 Sắp xếp nhanh – Quick sort
 Ý tưởng (sử dụng phương pháp chia và trị):
 Thực hiện phân hoạch dãy S cần sắp thành 3 dãy S1, S2, S3. Trong đó:
• S2 chỉ có một phần tử
• Tất cả các phần tử của dãy S3 đều > phần tử của dãy S2.
• Tất cả các phần tử của dãy S1 đều ≤ phần tử của dãy S2
• Dãy S1, S3 có thể là rỗng
 Tiếp tục phân hoạch dãy S1 và S3 độc lập theo nguyên tắc trên đến
khi dãy cần thực hiện phân hoạch chỉ có một phần tử thì dưng lại. Khi
đó ta được dãy các phần tử được sắp.
Thuật toán sắp xếp Quick sort
 Từ ý tưởng của thuật toán, ta có thể dễ dàng xây dựng thuật toán sắp xếp
dưới dạng đệ qui như sau:
 Algorithm QuickSort (array A, i, j );
 Input: Dãy các phần tử A[i],..,A[j] và hai số nguyên i, j
 Output: Dãy A[i],..,A[j] được sắp.
 if i < j then
 Partition (A,i, j, k); //k lấy chỉ số của phần tử làm S2
 Quicksort (A,i, k-1);
 Quicksort (A,k+1, j);
Thuật toán phân hoạch
• Chọn một phần tử bất kỳ của dãy làm dãy S2 (phần tử này được gọi là phần
tử chốt -pivot).
• Thực hiện chuyển các phần tử có khóa ≤ phần tử chốt về bên trái và các phần
tử > phần tử chốt về bên phải, sau đó đặt phần tử chốt về đúng vị trí của nó
trong dãy.
Chú ý :
• Phần tử chốt có thể được chọn là một phần tử bất kỳ của dãy.
 - Phần tử chốt có thể chọn là phần tử đầu hoặc giữa hoặc cuối dãy.
- Tốt nhất là chọn phần tử chốt mà nó làm cho việc phân hoạch thành hai dãy
S1 và S3 có số phần tử xấp xỉ bằng nhau.
Thuật toán
• Phân hoạch dãy gồm các phần tử A[i],..,A[j]
• Chọn phần tử đầu dãy làm chốt
• Sử dụng 2 biến left và right:
- left chạy từ trái sang phải bắt đầu từ i.
- right chạy từ phải sang trái bắt đầu từ j
- Biến left được tăng cho tới khi A[left].Key> A[i].Key
hoặc left >right
- Biến right được giảm cho tới khi A[right].Key <=
A[i] .Key
- Nếu left< right thì ta đổi A[left] và A[right]
- Quá trình trên được lặp lại cho tới khi nào left > right
- Cuối cùng tráo đổi A[i] và A[right]
Thuật toán phân hoạch
Algorithm Partition (Array A, i, j, &right )
Input: Dãy các phần tử A[i],..,A[j], 2 số nguyên i, j
Output: Dãy A[i],..,A[j] được phân hoạch, right là chỉ số
của
phần tử làm S2.
p  A[i];
left  i; right  j;
while ( left < right )
while( A[left].Key <= p.Key && left≤right)
left  left+1;
while( A[right].Key > p.Key ) right right-1;
 if left < right then
SWAP(A[left],A[right]);
if i<> right then
A[i]  A[right];
A[right]  p;
Thời gian chạy
• Thủ tục partition kiểm tra tất cả các phần tử trong mảng nhiều nhất một lần,
vì vậy nó mất thời gian tối đa là O(n).
• Thủ tục partition sẽ chia phần mảng được sắp thành 2 phần.
• Mặt khác cần chia liên tiêp n phần tử thành hai phần thì số lần chia nhiều
nhất là log2n lần.
• Vậy thời gian chạy của thuật toán QuickSort là O(nlogn)

Thuật toán MergeSort

Ý tưởng:
• Giả sử ta có hai dãy A[i],..,A[k] và A[k+1],..,A[j] và hai dãy này đã được
sắp.
• Thực hiện trộn hai dãy trên để được dãy A[i],..,A[j] cũng được sắp
• Do hai dãy A[i],..,A[k] và dãy A[k+1],..,A[j] đã được sắp nên việc trộn hai
dãy thành một dãy được sắp là rất đơn giản.
• Vậy trộn như thế nào?
Thuật toán trộn
• Sử dụng hai biến left, right, t và sử dụng mảng phụ B[i],..,B[j]. left xuất phát
từ i, right xuất phát từ k+1, t xuất phát tử i trên mảng phụ B.
• Nếu A[left].key<A[right].key thì B[t]A[left], t t+1 và leftleft+1
• Nếu A[left].keyA[right].key thì B[t]A[right], t t+1 và rightright+1
• Quá trình trên được thực hiện cho đến khi left>k hoặc right>j thì dừng lại.
 • Nếu left>k thì B[t]A[right],..,B[j]A[j].
• Nếu right>j thì B[t]A[left], B[t+1]A[letf+1],.., B[t+k-left]A[k].
• Gán A[i] B[i], .., A[j] B[j]
Mảng biểu diễn cây heap
• Mảng A[1],..,A[n] là mảng biểu diễn cây heap nếu:
• A[i]A[2i] và A[i]A[2i+1] với i=1..n/2
• Như vậy phần tử đầu của mảng có giá trị lớn nhất
Thuật toán sắp xếp vun đống
Ý tưởng:
• Tạo mảng A[1],..,A[n] biểu diễn cây Heap.
• Tráo đổi phần tử A[1] với phần tử A[n].
• Tạo mảng A[1],..,A[n-1] biểu diễn cây heap
• Tráo đổi phần tử A[1] với phần tử A[n-1].
• Lặp lại quá trình trên đến khi mảng chỉ còn 1 phần tử
Tạo mảng biểu diễn cây heap
• Theo tính chất của mảng biểu diễn cây Heap thì các phần tử từ n/2+1 đến n
không cần điều kiện ràng buộc. Vì vậy ta thực coi các phần tử này đã thỏa
mãn điều kiện cây heap.
• Ta thực hiện:
- Bổ sung phần tử n/2 vào A[n/2+1],..,A[n] để được mảng gồm
A[n/2],..,A[n] thỏa mãn kiện
- Bổ sung phần tử n/2-1 vào A[n/2],..,A[n] để được mảng gồm A[n/2-
1] ,..,A[n] thỏa mãn kiện
- Và cứ tiếp tục làm như vậy cho đến khi bổ sung phần tử A[1] vào
A[2],..,A[n] để được mảng gồm A[1],..,A[n] thỏa mãn điều kiện
Algorithm Heapsort(Array A, n);
Input: Mảng A có n phần tử và số nguyên n
Output: Mảng A được sắp theo thứ tự tăng dần của thuộc tính khóa
for i n/2 downto 1 do
Pushdown(A, i, n);
for i ndownto 2 do
swap(A[1],A[i]);
Pushdown(A,1,i-1);

Thời gian chạy

• Thời gian thực hiện thủ tục Pushdown.
 Là t/g thực hiện của vòng lặp while.
 Gọi k là số lần lặp, ta có i*2k  n hay k  log2(n/i).
 T/g thực hiện hàm Pushdown (A,i, n) là 0(log(n/i)
• Xét thủ tục HeapSort 
 Vòng lặp for đầu có số lần lặp là n/2
 Mỗi lần gọi hàm Pushdown 1 lần. Do đó t/g thực hiện là 0(log2n).
 Tương tự, vòng lặp for thứ 2 có số lần lặp là n-1. 0(nlog2n).
 Vì vậy t/g thực hiện HeapSort là O(nlog2n).

PHẦN II: Chương tình quản lý thư viện bằng ngôn ngữ C++
Nhóm chọn đề tài này vì nó thể hiện được gần hết những thứ đã được học
trong môn cấu trúc dữ liệu
Giao diện chương trình
 CHƯƠNG 3. KẾT QUẢ VÀ KIẾN NGHỊ
3.1 Kết quả đạt được
3.2 Kiến nghị
 PHỤ LỤC
Phụ lục 1: hướng dẫn cài đặt
Phụ lục 2: hướng dẫn sử dụng