Tài liệu ôn tập cấu trúc dữ liệu giải thuật

Câu 1đ6: Viết chương trình C/C++ cài đặt giải thuật sắp
xếp chèn (insertSort). Áp dụng giải thuật đã cài đặt để

sắp xếp dãy khóa tăng dần, dãy khóa là các số nguyên có
n phần tử đọc vào mảng động từ tệp văn bản 'daykhoa-
kt-de06bail.txt. Đưa ra màn hình dãy khóa ban đầu và
dãy khóa đã sắp xếp.
Lời giải:
#include <iostream>
#include <fstream>
#include <vector>
using namespace std;
// Hàm sắp xếp chèn

void insertSort(vector<int>& arr) {
int n = arr.size();
for (int i = 1; i < n; ++i) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {

arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
Downloaded by Nghi?p ?oàn V?n (nghiepdv.k43@c3nguyendu.edu.vn)

int main() {
// Mở tệp văn bản để đọc dãy khóa
ifstream inputFile("daykhoa-kt-de06bail.txt");
if (!inputFile.is_open()) {
cout << "Không thể mở tệp. Kiểm tra lại đường
dẫn." << endl;
return 1;
}
// Đọc dãy khóa từ tệp

vector<int> keyArray;
int key;
while (inputFile >> key) {

keyArray.push_back(key);
}
// Đóng tệp
inputFile.close();
// Hiển thị dãy khóa ban đầu

cout << "Dãy khóa ban đầu: ";
for (int i : keyArray) {
cout << i << " ";
}
cout << endl;
// Áp dụng giải thuật sắp xếp chèn

insertSort(keyArray);
// Hiển thị dãy khóa đã sắp xếp
cout << "Dãy khóa đã sắp xếp: ";
for (int i : keyArray) {
cout << i << " ";
}
cout << endl;
return 0;
}
Câu 2đ6: Cài đặt cấu trúc dữ liệu ngăn xếp sử dụng cấu
trúc lưu trữ phân tán, ngăn xếp có phần tử dữ liệu là ký
tự. Sử dụng ngăn xếp đã cài đặt để chuyển một số
nguyên dương n nhập vào từ bàn phím sang số hex. Ghi
số nguyên dương n và số hex ra tệp văn bản 'thctdlgt-
thi-ketqua.txt
Lời giải:
#include <iostream>
#include <fstream>
#include <stack>
// Cấu trúc lưu trữ phân tán

struct Node {
char data;
Node* next;
};
// Cấu trúc ngăn xếp

class Stack {
private:
Node* top;
public:
Stack() : top(nullptr) {}
// Hàm kiểm tra ngăn xếp có rỗng hay không

bool isEmpty() {
return top == nullptr;
}
// Hàm đẩy phần tử vào ngăn xếp

void push(char data) {
Node* newNode = new Node{data, top};
top = newNode;
}
// Hàm lấy và loại bỏ phần tử khỏi ngăn xếp

char pop() {
if (isEmpty()) {
cerr << "Ngan xep rong." << endl;
exit(EXIT_FAILURE);
}
Node* temp = top;

char data = temp->data;
top = temp->next;
delete temp;
return data;
}
// Hàm lấy phần tử đầu ngăn xếp mà không loại bỏ nó

char peek() {
if (isEmpty()) {
exit(EXIT_FAILURE);
}
return top->data;
}
};
// Hàm chuyển số nguyên dương sang số hex và ghi vào

tệp
void convertAndWriteToFile(int n) {
// Khởi tạo ngăn xếp
Stack hexStack;
// Chuyển đổi và đẩy ký tự hex vào ngăn xếp

while (n != 0) {
int remainder = n % 16;
char hexDigit = (remainder < 10) ? (char)(remainder
+ '0') : (char)(remainder - 10 + 'A');
hexStack.push(hexDigit);
n /= 16;
}
// Mở tệp văn bản để ghi

ofstream outputFile("thctdlgt-thi-ketqua.txt");
// Ghi số nguyên dương và số hex vào tệp

outputFile << "So nguyen duong: " << n << endl;
outputFile << "So hex tuong ung: ";
while (!hexStack.isEmpty()) {
outputFile << hexStack.pop();
}
outputFile << endl;
// Đóng tệp
outputFile.close();
}
int main() {
// Nhập số nguyên dương từ bàn phím
int n;
cout << "Nhap so nguyen duong n: ";
cin >> n;
// Chuyển đổi và ghi vào tệp

convertAndWriteToFile(n);
cout << "Da ghi ket qua vao tep thctdlgt-thi-

ketqua.txt." << endl;

return 0;
}
Câu 1đ9: Cài đặt giải thuật sắp xếp chọn

(selectionSort) để sắp xếp danh sách mặt hàng theo số
lượng giảm dần. Mỗi mặt hàng có thông tin về tên hàng,
số lượng, đơn giá. Danh sách n mặt hàng đọc vào mảng
động từ tệp văn bản "mathang.txt". Đưa ra màn hình
danh sách mặt hàng ban đầu và sau khi sắp xếp
Lời giải:
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
// Cấu trúc mặt hàng

struct Item {
string name;
int quantity;
float price;
};
// Hàm sắp xếp chọn theo số lượng giảm dần

void selectionSort(vector<Item>& items) {
int n = items.size();

for (int i = 0; i < n - 1; ++i) {
int maxIndex = i;
for (int j = i + 1; j < n; ++j) {

if (items[j].quantity > items[maxIndex].quantity) {
maxIndex = j;
}
}
swap(items[i], items[maxIndex]);
}
}
int main() {
// Mở tệp văn bản để đọc danh sách mặt hàng
ifstream inputFile("mathang.txt");
cout << "Không thể mở tệp. Kiểm tra lại đường
dẫn." << endl;
return 1;
}
// Đọc danh sách mặt hàng từ tệp

vector<Item> itemList;
Item item;
while (inputFile >> item.name >> item.quantity >>
item.price) {
itemList.push_back(item);
}
// Đóng tệp
inputFile.close();
// Hiển thị danh sách mặt hàng ban đầu

cout << "Danh sach mat hang ban dau:" << endl;
for (const auto& it : itemList) {
cout << it.name << " " << it.quantity << " " << it.price
<< endl;
}
// Áp dụng giải thuật sắp xếp chọn

selectionSort(itemList);
// Hiển thị danh sách mặt hàng sau khi sắp xếp
cout << "\nDanh sach mat hang sau khi sap xep theo
so luong giam dan:" << endl;
for (const auto& it : itemList) {
cout << it.name << " " << it.quantity << " " << it.price
<< endl;
}
return 0;
}
Câu 2đ9: Cài đặt cấu trúc dữ liệu ngăn xếp lưu trữ
phân tán có phần tử dữ liệu là kiểu cấu trúc thí sinh. Mỗi
thí sinh có thông tin về số báo danh, họ tên, giới tính,
điểm thi. Sử dụng ngăn xếp đã cài đặt cho bài toán: Cho
tệp văn bản "thisinh.txt" chứa danh sách n thí sinh đã
được sắp xếp theo điểm thi tăng dần; đọc tệp và đưa ra
màn hình danh sách thí sinh nam theo thứ tự điểm thi
giảm dần
Lời giải:
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
// Cấu trúc thông tin thí sinh

struct ThiSinh {
int soBaoDanh;
string hoTen;
char gioiTinh;
float diemThi;
};
// Cấu trúc lưu trữ phân tán

struct Node {
ThiSinh data;
Node* next;
};
// Cấu trúc ngăn xếp lưu trữ phân tán

class Stack {
private:
Node** table;
int tableSize;
// Hàm băm đơn giản

int hashFunction(int key) {
return key % tableSize;
}
public:
Stack(int size) : tableSize(size) {
table = new Node*[tableSize]();
}
// Hàm đẩy phần tử vào ngăn xếp

void push(ThiSinh data) {
int index = hashFunction(data.diemThi);
Node* newNode = new Node{data, table[index]};
table[index] = newNode;
}
// Hàm lấy và loại bỏ phần tử khỏi ngăn xếp

ThiSinh pop() {
if (isEmpty()) {
exit(EXIT_FAILURE);
}
int index = 0;
while (table[index] == nullptr) {

++index;
}
Node* temp = table[index];

ThiSinh data = temp->data;
table[index] = temp->next;
delete temp;
return data;
}
// Hàm kiểm tra ngăn xếp có rỗng hay không

bool isEmpty() {
for (int i = 0; i < tableSize; ++i) {
if (table[i] != nullptr) {
return false;
}
}
return true;
}
};
int main() {
// Mở tệp văn bản để đọc danh sách thí sinh
ifstream inputFile("thisinh.txt");
cout << "Khong the mo tep. Kiem tra lai duong dan."
<< endl;
return 1;
}
// Đọc danh sách thí sinh từ tệp

vector<ThiSinh> thisinhList;
ThiSinh ts;
while (inputFile >> ts.soBaoDanh >> ts.hoTen >>

ts.gioiTinh >> ts.diemThi) {
thisinhList.push_back(ts);
}
// Đóng tệp
inputFile.close();
// Áp dụng giải thuật sắp xếp theo điểm tăng dần

sort(thisinhList.begin(), thisinhList.end(), [](const
ThiSinh& a, const ThiSinh& b) {
return a.diemThi < b.diemThi;
});
// Hiển thị danh sách thí sinh nam theo thứ tự điểm
giảm dần
Stack namStack(thisinhList.size());
cout << "Danh sach thi sinh nam theo thu tu diem
giam dan:" << endl;
for (const auto& ts : thisinhList) {
if (ts.gioiTinh == 'M') {
namStack.push(ts);
}
}
while (!namStack.isEmpty()) {
ThiSinh ts = namStack.pop();
cout << ts.soBaoDanh << " " << ts.hoTen << " " <<
ts.gioiTinh << " " << ts.diemThi << endl;
}
return 0;
}
Câu 1đ8: Cài đặt giải thuật sắp xếp sủi bọt (bubbleSort)
để sắp xếp một dãy số thực theo thứ tự giảm dần. Danh
sách số thực đọc vào mảng động từ tệp văn bản
"dayso.txt". Trong tệp dayso.txt : dòng đầu chứa số
nguyên n là phần tử có trong dãy số. Dòng thứ hai chứa
danh sách n số thực cách nhau bởi dấu cách. Đưa ra
màn hình danh sách dãy số ban đầu và sau khi sắp xếp.
Nếu n<=0 thì đưa ra màn hình dòng thông báo “Dãy số
trống không có phần tử nào".
Lời giải:
#include <iostream>
#include <fstream>
#include <vector>
// Hàm sắp xếp sủi bọt

void bubbleSort(vector<double>& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; ++i) {

for (int j = 0; j < n - i - 1; ++j) {
if (arr[j] < arr[j + 1]) {
swap(arr[j], arr[j + 1]);
}
}
}
}
int main() {
// Mở tệp văn bản để đọc dãy số
ifstream inputFile("dayso.txt");
<< endl;
return 1;
}
// Đọc số lượng phần tử n

int n;
inputFile >> n;
// Kiểm tra n và hiển thị thông báo nếu dãy số trống

if (n <= 0) {
cout << "Day so trong khong co phan tu nao." <<
endl;
return 0;
}
// Đọc danh sách dãy số từ tệp

vector<double> numberList(n);
for (int i = 0; i < n; ++i) {

inputFile >> numberList[i];
}
// Đóng tệp
inputFile.close();
// Hiển thị dãy số ban đầu

cout << "Day so ban dau: ";
for (const auto& num : numberList) {
cout << num << " ";
}
cout << endl;
// Áp dụng giải thuật sắp xếp sủi bọt

bubbleSort(numberList);
// Hiển thị dãy số sau khi sắp xếp

cout << "Day so sau khi sap xep giam dan: ";
for (const auto& num : numberList) {
cout << num << " ";
}
cout << endl;

return 0;
}
Câu 2đ8: Cài đặt cấu trúc dữ liệu danh sách liên kết đơn
(DSLKD) có phần tử dữ liệu là kiểu cấu trúc mặt hàng.
Mỗi mặt hàng có thông tin về tên hàng, số lượng, đơn
giá. Sử dụng DSLKD đã cài đặt cho bài toán: Cho tệp văn
bản "mathang.txt" chứa danh sách n mặt hàng; Trong
tệp mathang.txt : dòng đầu chứa n là số mặt hàng. Các
dòng tiếp theo chứa thông tin của các mặt hàng, trong
đó mỗi mặt hàng chiếm 03 dòng và 03 dòng đó lần lượt
chứa: tên hàng, số lượng, đơn giá Đọc danh sách n mặt
hàng từ tệp lưu vào DSLKD; đưa danh sách mặt hàng
trong DSLKD ra màn hình; tìm và đưa ra mặt hàng trong
DSLKD mà có đơn giá cao nhất
Lời giải:
#include <iostream>
#include <fstream>
#include <string>
// Cấu trúc mặt hàng

struct MatHang {
string tenHang;
int soLuong;
float donGia;
MatHang* next;
};
// Cấu trúc danh sách liên kết đơn

class LinkedList {
private:
MatHang* head;
public:
LinkedList() : head(nullptr) {}
// Hàm thêm một mặt hàng vào danh sách

void addMatHang(MatHang* newItem) {
newItem->next = head;
head = newItem;
}
// Hàm hiển thị danh sách mặt hàng

void displayList() {
MatHang* current = head;
while (current != nullptr) {

cout << "Ten hang: " << current->tenHang <<
endl;
cout << "So luong: " << current->soLuong << endl;
cout << "Don gia: " << current->donGia << endl <<
endl;
current = current->next;
}
}
// Hàm tìm mặt hàng có đơn giá cao nhất
MatHang* findMaxDonGia() {
if (head == nullptr) {
return nullptr;
}
MatHang* maxItem = head;

MatHang* current = head->next;
while (current != nullptr) {

if (current->donGia > maxItem->donGia) {
maxItem = current;
}
}
return maxItem;
}
};
int main() {
// Mở tệp văn bản để đọc danh sách mặt hàng
ifstream inputFile("mathang.txt");
<< endl;
return 1;
}
// Đọc số lượng mặt hàng n
int n;
inputFile >> n;
// Tạo danh sách liên kết đơn và đọc danh sách mặt
hàng từ tệp
LinkedList matHangList;
for (int i = 0; i < n; ++i) {
MatHang* newItem = new MatHang;
inputFile.ignore(); // Đọc và bỏ qua ký tự xuống
dòng
getline(inputFile, newItem->tenHang);
inputFile >> newItem->soLuong >> newItem-
>donGia;
matHangList.addMatHang(newItem);
}
// Đóng tệp
inputFile.close();
// Hiển thị danh sách mặt hàng

cout << "Danh sach mat hang trong DSLKD:" << endl;
matHangList.displayList();
// Tìm và hiển thị mặt hàng có đơn giá cao nhất

MatHang* maxDonGiaItem =
matHangList.findMaxDonGia();
if (maxDonGiaItem != nullptr) {
cout << "Mat hang co don gia cao nhat:" << endl;
cout << "Ten hang: " << maxDonGiaItem->tenHang
<< endl;
cout << "So luong: " << maxDonGiaItem->soLuong
<< endl;
cout << "Don gia: " << maxDonGiaItem->donGia <<
endl;
} else {
cout << "Danh sach mat hang trong, khong co mat
hang nao." << endl;
}
return 0;
}
……………………………
#include<iostream>
#include<fstream>
#include<string.h>
// Khai báo kiểu phần tử dữ liệu của DSLKD

struct MatHang
{
char tenHang[31];
int soLuong;
float donGia;
};
// Khai báo cấu trúc nút cho DSLKD

struct Node
{
MatHang infor;
Node *next;
};
// Khai báo các hàm thao tác trên DSLKD

void SLInsert(Node* &head, MatHang x);
void SLDisplay(Node* head);
MatHang SLMax(Node* head);
//===chuong trinh chinh===

int main()
{
// Cài đặt cấu trúc DSLKD với head
Node *head = NULL;
// Mở tệp văn bản để đọc

ifstream fin("mathang.txt");
// Các biến cần thiết

int n;
MatHang x;
// Đọc số lượng mặt hàng từ tệp

fin >> n;
// Đọc danh sách n mặt hàng từ tệp vào DSLKD

for (int i = 0; i < n; i++)
{
fin.ignore(); // Xóa bộ đệm của getline
fin.getline(x.tenHang, sizeof(x.tenHang));
fin >> x.soLuong >> x.donGia;
SLInsert(head, x);
}
// Hiển thị danh sách mặt hàng

cout << "Danh sach mat hang trong DSLKD la:\n";
SLDisplay(head);
// Tìm và hiển thị mặt hàng có đơn giá cao nhất

MatHang giaMHCN = SLMax(head);
cout << "\nMat hang co don gia cao nhat la:\n";
cout << "\tTen mat hang: " << giaMHCN.tenHang <<
endl;
cout << "\tSo luong: " << giaMHCN.soLuong << endl;
cout << "\tDon gia: " << giaMHCN.donGia << endl;
// Giải phóng bộ nhớ khi kết thúc chương trình
Node *current = head;
while (current != NULL)
{
Node *temp = current;
delete temp;
}
return 0;
}
//===dinh nghia ham===

void SLInsert(Node* &head, MatHang x)
{
Node *N = new Node;
N->infor = x;
N->next = NULL;
if (head == NULL) // DSLKD rỗng

{
head = N;
}
else
{
N->next = head;
head = N;
}
}
void SLDisplay(Node* head)

{

{
cout << "\n\tTen mat hang: " << current-
>infor.tenHang;
cout << "\n\tSo luong: " << current-
>infor.soLuong;
cout << "\n\tDon gia: " << current->infor.donGia;
printf("\n\tThanh tien: %0.1f\n", current-
>infor.soLuong * current->infor.donGia);
}
}
MatHang SLMax(Node* head)

{
MatHang giaMHCN;
giaMHCN.donGia = 0;

{
if (current->infor.donGia > giaMHCN.donGia)
{
giaMHCN = current->infor;
}
}
return giaMHCN;
}MỤC LỤC
Bài 00(thctdlgtbai00.cpp): Tính diện tích và chu vi
hình tam giác
.......................................................................................
4
có 3 cạnh a,b,c đọc vào từ tệp văn bản 'tamgiac.txt'.
Đưa kết quả ra màn hình,
.......................................................................................
4
đồng thời ghi ra tệp văn bản 'kq-thctdlgtbai00.txt'......4
Bài 01(thctdlgtbai01.cpp): Đọc vào mảng động dãy số
nguyên có n phần tử từ tệp văn bản
'daysonguyen.txt'.Đưa các số lẻ về đầu dãy, các số
chẵn về cuối dãy. Viết 1 hàm đưa dãy số ra màn hình,
1 hàm hoán đổi nội dung 2 ô nhớ, 1 hàm đổi chỗ các
số chẵn, lẻ. Lưu dãy số sau khi thay đổi ra tệp văn bản
'kq- thctdlgtbai01.txt'
.......................................................................................
6
Bài 02(thctdlgtbai02.cpp): Tính n! theo giải thuật đệ
quy.................................................................................7
Bài 04(thctdlgtbai04.cpp): Cho ma trận số nguyên kích
thước mxn chứa trong tệp văn bản 'matran.txt'. Đọc
ma trận từ tệp vào mảng động. Đưa ma trận từ mảng
ra màn hình theo định dạng hàng, cột. Tính tổng và
trung bình cộng các phần tử của ma trận
.......................................................................................
7
Bài 05(thctdlgtbai05.cpp): Tính tổng 2 ma trận nguyên:
Cmxn
= Amxn + Bmxn. Ma trận Amxn để trong tệp văn bản
'matran- A.txt', ma trận Bmxn để trong tệp văn bản
'matran-B.txt'. Ma trận tổng Cmxn được ghi ra tệp văn
bản 'kq-thctdlgtbai05.txt'. Yêu cầu sử dụng mạng động
chứa các ma trận, viết hàm đọc vào ma trận từ tệp,
hàm đưa ra ma trận và hàm cộng 2 ma trận
.....................................................................................
11
Bài 06(thctdlgtbai06.cpp): Tính tích 2 ma trận nguyên:
Cmxn = Amxp * Bpxn. Ma trận Amxp để trong tệp văn
bản 'matran- A.txt', ma trận Bpxn để trong tệp văn
bản 'matran-B.txt'. Ma trận tích Cmxn được ghi ra tệp
văn bản 'kt-thctdlgtbai06.txt'.
Yêu cầu sử dụng mạng động chứa các ma trận, viết
hàm đọc vào ma trận từ tệp, hàm đưa ra ma trận và
hàm nhân 2 ma trận
.....................................................................................
14
Bài 07(thctdlgtbai07.cpp): Cài đặt cấu trúc dữ liệu ngăn
xếp sử dụng
.....................................................................................
16
cấu trúc lưu trữ kế tiếp với phần tử dữ liệu là ký tự.
Sử dụng ngăn xếp chuyển
.....................................................................................
16
1
một số nguyên dương hệ 10 sang hệ 2. Đưa ra bit
MSB của số nhị phân tìm được
.....................................................................................
16
Bài 08(thctdlgtbai08.cpp): Cài đặt cấu trúc dữ liệu ngăn
xếp sử dụng
.....................................................................................
18
.....................................................................................
18
một số nguyên dương hệ 10 sang hệ 16....................18
Bài 10(thctdlgtbai10.cpp): Cài đặt cấu trúc dữ liệu hàng
đợi sử dụng cấu trúc lưu trữ kế tiếp theo kiểu quay
vòng với phần tử dữ liệu là số nguyên. Sử dụng hàng
đợi cho bài toán: Đọc vào dãy số nguyên dương từ
tệp văn bản 'daysonguyen.txt', trên tệp không có
thông tin về số phần tử của dãy. Tách dãy
số thành dãy các số chẵn và dãy các số lẻ
20
Bài 11(thctdlgtbai11.cpp): Cài đặt cấu trúc dữ liệu hàng
đợi sử dụng
.....................................................................................
22
cấu trúc lưu trữ kế tiếp theo kiểu quay vòng. Sử dụng
hàng đợi cho bài toán
.....................................................................................
22
Có một tệp danh sách sinh viên, mỗi sinh viên có thông
tin gồm mã sv, họ tên, giới tính, điểm tbc
.....................................................................................
22
Danh sách sinh viên trên tệp đã được sắp xếp theo
điểm tbc giảm dần
.....................................................................................
22
Ghi lại tệp sao cho tất cả sinh viên nữ ở đầu danh sách,
tất cả sinh viên nam ở cuối danh sách,
.....................................................................................
22
điểm tbc vẫn giảm dần trong nhóm nam và nữ.........22
Bài 12(thctdlgtbai12.cpp): Cài đặt danh sách liên kết
đơn có phần tử dữ liệu là số nguyên, với cácbphép
toán sau
.....................................................................................
25
1) Bổ sung phần tử dữ liệu x vào sau nút M...............25
2) Bổ sung phần tử dữ liệu x vào trước nút M...........25
3) Xóa nút M................................................................25
4) Duyệt danh sách để đưa các phần tử dữ liệu ra màn
hình...........................................................................25
5)Tìm một nút có phần tử dữ liệu bằng x, nếu có trả về
địa chỉ nút, nếu không có trả về rỗng
25
Sử dụng danh sách liên kết đơn P để lưu trữ dãy số
nguyên theo thứ tự đọc vào
.....................................................................................
25

2
từ tệp văn bản 'daysonguyen.txt', trên tệp không có
thông tin về số phần tử của dãy số
.....................................................................................
25
Tạo danh sách liên kết đơn Q bao gồm các phần tử
dữ liệu của P nhưng theo thứ tự đảo ngược
.....................................................................................
25
Xóa một nút trên DSLK đơn P mà có phần tử dữ liệu
bằng x nhập vào từ bàn phím
.....................................................................................
25
Bài 13(thctdlgtbai13.cpp): Cài đặt và sử dụng danh
sách liên kết đơn cho bài toán sau: Đọc danh sách sinh
viên từ tệp văn bản 'sinhvien.txt' lưu vào DSLKD, mỗi
sinh viên có thông tin về mã sinh viên, họ tên, lớp,
điểm tbc. Xóa sinh viên có mã nhập vào từ bàn phím.
Tìm và đưa ra màn hình các sinh viên có điểm tbc >=
6.5.
.....................................................................................
31
kép có phần tử dữ liệu là số nguyên, với các
.....................................................................................
35
phép toán sau..............................................................35
1) Bổ sung phần tử dữ liệu x vào sau nút M...............35
2) Bổ sung phần tử dữ liệu x vào trước nút M...........35
3) Xóa nút M................................................................35
4)Duyệt danh sách để đưa các phần tử dữ liệu ra màn
hình từ trái sang phải
35
và từ phải sang trái......................................................35
5)Tìm một nút có phần tử dữ liệu bằng x, nếu có trả về
địa chỉ nút, nếu không có trả về rỗng
35
Sử dụng danh sách liên kết kép để lưu trữ dãy số
.....................................................................................
35
từ tệp văn bản 'daysonguyen.txt', trên tệp không có
thông tin về số phần tử của dãy số
.....................................................................................
35
Đưa dãy số nguyên trong DSLKK ra màn hình theo thứ
tự từ trái sang phải và từ phải sang trái
.....................................................................................
35
Xóa tất cả các nút mà có phần tử dữ liệu bằng x nhập
vào từ bàn phím
.....................................................................................
35
Bài 15(thctdlgtbai15.cpp): Cài đặt và sử dụng danh
sách liên kết kép cho bài toán sau: Đọc danh sách mặt
hàng từ tệp văn bản 'mathang.txt' lưu vào DSLKK, mỗi
mặt hàng có thông tin về mã hàng, tên hàng, số lượng,
đơn giá. Đưa danh sách mặt hàng
3
ra màn hình kèm theo số tiền của từng mặt hàng và
tổng số tiền của tất cả mặt hàng. Xóa mặt hàng có mã
nhập vào từ bàn phím.................................................39
Bài 16(thctdlgtbai16.cpp): Cài đặt ngăn xếp sử dụng
cấu trúc lưu trữ phân tán với phần tử dữ liệu là số
nguyên. Ứng dụng ngăn xếp cho bài toán tìm và đưa
ra các số nguyên tố nhỏ hơn n theo thứ tự giảm dần
.....................................................................................42
Bài 18(thctdlgtbai18.cpp): Cài đặt và sử dụng hàng đợi
lưu trữ phân tán cho bài toán sau: Cho tệp văn bản
'dathuc.txt' chứa đa thức tuyến tính bậc n. Đọc tệp,
đưa ra màn hình đa thức bậc n theo dạng Pn(x) = a0 +
a1x + a2x^2 + a3x^3 +...+ anx^n. Nhập vào x, tính Pn(x)
.....................................................................................45
Bài 24(thctdlgtbai24.cpp). Cho dãy khóa n phần tử là
các số nguyên lưu trữ trong tệp văn bản 'daykhoa.txt'.
Đọc dãy khóa từ tệp vào mảng động. Cài đặt giải thuật
sắp xếp chọn để sắp xếp dãy khóa trong mảng động
tăng dần. Đưa dãy khóa ban đầu và dãy khóa đã sắp
xếp ra màn hình...........................................................48
sắp xếp chèn để sắp xếp dãy khóa trong mảng động
xếp ra màn hình...........................................................49
sắp xếp sủi bọt để sắp xếp dãy khóa trong mảng động
xếp ra màn hình...........................................................51
sắp xếp nhanh để sắp xếp dãy khóa trong mảng động
xếp ra màn hình...........................................................52
các số nguyên lưu trữ trong........................................54
tệp văn bản 'daykhoa.txt'. Đọc dãy khóa từ tệp vào
mảng động. Cài đặt giải thuật tìm kiếm tuần tự để tìm
khóa có giá trị bằng
4
x, nếu tìm thấy thì trả về vị trí của khóa, nếu không tìm
thấy thì trả về 0
.....................................................................................
54
các số nguyên lưu trữ trong tệp văn bản
'daykhoatangdan.txt'. Đọc dãy khóa từ tệp vào mảng
động. Cài đặt giải thuật tìm kiếm nhị phân dạng không
đệ quy để tìm khóa có giá trị bằng x, nếu tìm thấy thì
trả về vị trí của khóa, nếu không tìm thấy thì trả về
0.
.....................................................................................55
Đọc dãy khóa từ tệp để tạo cây nhị phân tìm kiếm. Tìm
khóa có giá trị bằng x, nếu không tìm thấy thì bổ sung
x vào dãy khóa
.....................................................................................
58
Làm c 愃 Āc bài
Bài 00(thctdlgtbai00.cpp): Tính diện tích và chu vi
hình tam gi 愃 Āc
có 3 cạnh a,b,c đọc vào từ tệp văn bản 'tamgiac.txt'.
Đưa kết quả ra màn hình,
đồng thời ghi ra tệp văn bản 'kq-thctdlgtbai00.txt'.
#include<iostream>
#include<fstream>
#include<stdio.h>
#include<math.h>
//====Chuong trinh
chinh===== int main()
{
//Khai bao tep
ifstream fin("tamgiac.txt");
ofstream fout("kq-thctdlgtbai00.txt");
//Khai bao
bien float
a,b,c;

//Doc vao 3 canh tu tep
fin>>a>>b>>c;
if(a+b>c && a+c>b && b+c>a)

{
float cv =
a+b+c; float p
= cv/2;
float dt = sqrt(p*(p-a)*(p-b)*(p-c));
printf("Tam giac co 3 canh la:\na = %0.1f; b = %0.1f; c

=
%0.1f",a,b,c);
printf("\nDien tich tam giac la:
%0.1f ",dt); printf("\nChu vi tam
giac la: %0.1f ",cv);
//Ghi ket qua ra tep

fout<<"Tam giac co 3 canh la:\na = "<<a<<";b =
"<<b<<"; c = "<<c;
fout<<"\nDien tich tam giac la:
"<<dt; fout<<"\nChu vi tam giac
la: "<<cv;
}
else
{
printf("3 so tren tep khong phai la 3 canh cua tam
giac: %0.1f;
%0.1f; %0.1f",a,b,c);
//Ghi ket qua ra tep

fout<<"3 so tren tep khong phai la 3 canh cua tam
giac: "<<a<<"; "<<b<<"; "<<c;
}
//Thong bao da ghi ra tep
cout<<"\n\nDa ghi ket qua ra tep kq-
thctdlgtbai00.txt";
cout<<endl;
return 0;
}
//====Dinh nghia ham===
Bài 01(thctdlgtbai01.cpp): Đọc vào mảng động dãy

số nguyên có n phần tử từ tệp văn bản
'daysonguyen.txt'.Đưa
c 愃 Āc số lẻ về đầu dãy, c 愃 Āc số chẵn về cuối dãy.
Viết 1 hàm đưa

dãy số ra màn hình, 1 hàm ho 愃 Ān đổi nội dung 2 ô
nhớ, 1 hàm đổi chỗ c 愃 Āc số chẵn, lẻ. Lưu dãy số
sau khi thay đổi ra tệp văn bản 'kq-thctdlgtbai01.txt'.
#include<iostream>
#include<stdio.h>
#include<fstream>
using namespace
std;
//===chuong trinh
chinh=== int main()
{
float r,dt,cv;
ofstream fout("kq-
thctgdlgtbai00.txt"); ifstream
fin("hinhtron.txt");
fin>>r;
fin.close();
if(r>0)
{
cv=2*r*3.1
4;
dt=r*r*3.1
4;
cout<<"Hinh tron co ban kinh la: r="<<r<<'\n';

cout<<"Hinh tron co chu vi: "<<cv<<" va dien

tich
la:"<<dt<<'\n';
//luu file
fout<<"Hinh tron co ban kinh la: r="<<r<<'\n';
fout<<"Hinh tron co chu vi: "<<cv<<" va dien
tich
la:"<<dt<<'\n';
fout.close();
}
else
{
cout<<"Hinh tron co ban kinh khong hop
le"; fout<<"Hinh tron co ban kinh khong
hop le";
fout.close();
cout<<endl;
return 0;
}
}
7

Bài 02(thctdlgtbai02.cpp): Tính n! theo giải thuật đệ
quy.
#include<iostream>
#include<stdio.h>
using namespace
std; int
GiaiThua(int n);
//===chuong trinh
chinh=== int main()
{
int n;
cout<<"Chuong trinh tinh n!\nNhap so
nguyen n:"; cin>>n;
//in ket qua cout<<n<<"!

="<<GiaiThua(n);
cout<<endl;
return 0;
}
//===dinh nghia
ham=== int
GiaiThua(int n)
{
if(n==0)
return
1;
else
return n*GiaiThua(n-1);
}

Bài 04(thctdlgtbai04.cpp): Cho ma trận số nguyên
kích thước mxn chứa trong tệp văn bản 'matran.txt'.
Đọc ma trận từ tệp vào mảng động. Đưa ma trận từ
mảng ra màn hình theo định dạng hàng, cột. Tính
tổng và trung bình cộng c 愃 Āc phần tử của ma trận.
#include<iostream>
#include<fstream>
#include<stdio.h>
//Khai bao ham cai dat cac phep toan tren mang 2
chieu

void duaRa(int *V,int
m,int n); int tinhTong(int
*V,int m,int n); float
tinhTBC(int *V,int m,int
n);
//===chuong trinh
chinh=== int main()
{
//Khai bao tep vao
ifstream
fin("matran.txt");
//Khai bao
bien int m,n;
//Doc kich thuoc ma tran

tu tep fin>>m>>n;
//Cai dat cau truc luu tru cua

mang 2 chieu int *V = new
int[m*n];
//Doc ma tran tu tep

vao V for(int
i=1;i<=m;i++)
for(int j=1;j<=n;j++)
{
//Tinh chi so o
nho k int k = (i-
1)*n + j - 1;
//Doc phan tu aij vao

V[k] fin>>V[k];
}
9

cout<<"Ma tran doc duoc tu tep
la:\n"; duaRa(V,m,n);
printf("\nTong cac phan tu cua ma tran la:

%d",tinhTong(V,m,n)); printf("\nTrung binh cong cac
phan tu cua ma tran la:
%0.1f",tinhTBC(V,m,n));
cout<<endl;
return 0;
}
//===dinh nghia
ham=== void duaRa(int
*V,int m,int n)
{
for(int i=1;i<=m;i++)
{
//Dua ra hang i
for(int
j=1;j<=n;j++)
{

//Tinh chi so o
nho k int k = (i-
1)*n + j - 1;
//Dua ra phan tu ma tran aij o o nho

V[k] printf("%6d",V[k]);
}
//Xuong
dong
cout<<endl;
}
10

}
int tinhTong(int *V,int m,int n)

{
int tong = 0;
//Tinh tong cac phan tu cua

ma tran for(int i=1;i<=m;i++)
{
//Tinh chi so o
nho k int k = (i-
1)*n + j - 1;
//Cong vao
tong tong +=
V[k];
}
//Tra ve tong

return tong;
}
float tinhTBC(int *V,int m,int n)

{
float tong = 0;
//Tinh tong cac phan tu cua

ma tran for(int i=1;i<=m;i++)
{
11

//Tinh chi so o
nho k int k = (i-
1)*n + j - 1;
//Cong vao
tong tong +=
V[k];
}
//Tra ve TBC
return
tong/(m*n);
}
Bài 05(thctdlgtbai05.cpp): Tính tổng 2 ma trận

nguyên: Cmxn = Amxn + Bmxn. Ma trận Amxn để
trong tệp văn bản 'matran-A.txt', ma trận Bmxn để
trong tệp văn bản 'matran- B.txt'. Ma trận tổng
Cmxn được ghi ra tệp văn bản 'kq-
thctdlgtbai05.txt'. Yêu cầu sử dụng mạng động chứa
c 愃 Āc ma trận, viết hàm đọc vào ma trận từ tệp,
hàm đưa ra ma trận và hàm cộng 2 ma trận.
#include<iostream
>
#include<fstream>
using namespace
std;
void docVaoMT(int* &V,int &m,int &n,const

char *tenTep); int* congMT(int *V1,int *V2,int
m,int n);
void duaRaMT(int *V,int m,int n);
int main()
{
int *A,*B,*C;
int mA,nA,mB,nB;
12

docVaoMT(A,mA,nA,"matran-A.txt");
docVaoMT(B,mB,nB,"matran-B.txt");
cout<<"Ma tran A doc duoc tu tep matran-A.txt la:\

n"; duaRaMT(A,mA,nA);
cout<<"Ma tran B doc duoc tu tep matran-B.txt la:\
n"; duaRaMT(B,mB,nB);
if(mA==mB && nA==nB)

{
C=congMT(A,B,mA,nA);
cout<<"Ma tran tong C la:\
n"; duaRaMT(C,mA,nA);
ofstream fout("kq-
thctdlgtbai05.txt");
fout<<mA<<'\t'<<nA<<endl;
for(int i=1;i<=mA;i++)
{
for(int j=1;j<=nA;j++)

fout<<'\t'<<C[(i-
1)*nA+j-1];
fout<<endl;
}
cout<<"Da ghi ma tran tong C vao tep kq-
thctdlgtbai05.txt";
}
else
cout<<"2 ma tran co kich thuoc khac nhau,
khong cong
duoc!";
cout<<endl;
13

return 0;
}
void docVaoMT(int* &V,int &m,int &n,const char
*tenTep)
{
ifstream fin(tenTep);
fin>>m>>n;
V=new
int[m*n];
fin>>V[(i-1)*n+j-1];
}
int* congMT(int *V1,int *V2,int m,int n)

{
int *V3=new
int[m*n]; for(int
i=1;i<=m;i++)
V3[(i-1)*n+j-1]=V1[(i-1)*n+j-1]+V2[(i-1)*n+j-1];
return V3;
}
void duaRaMT(int *V,int m,int n)

{
{
cout<<'\t'<<V[(i-
1)*n+j-1];
14

cout<<endl;
}
}
Bài 06(thctdlgtbai06.cpp): Tính tích 2 ma trận nguyên:

Cmxn
= Amxp * Bpxn. Ma trận Amxp để trong tệp văn bản
'matran- A.txt', ma trận Bpxn để trong tệp văn bản
'matran-B.txt'. Ma trận tích Cmxn được ghi ra tệp văn
bản 'kt-thctdlgtbai06.txt'. Yêu cầu sử dụng mạng động
chứa c 愃 Āc ma trận, viết hàm đọc vào ma trận từ
tệp, hàm đưa ra ma trận và hàm nhân 2 ma trận.
#include<iostream>
#include<stdio.h>
#include<fstream>
void docVaoMT(int* &V,int &m,int &n,const

char *tenTep); int* tichMT(int *V1,int *V2,int
m,int p,int n);
void duaRaMT(int *V,int m,int n);
int main()
{
int *A,*B,*C;
int mA,nA,mB,nB;

docVaoMT(A,mA,nA,"matran-A.txt");
docVaoMT(B,mB,nB,"matran-B.txt");
cout<<"Ma tran A doc duoc tu tep matran-A.txt la:\

n"; duaRaMT(A,mA,nA);
cout<<"Ma tran B doc duoc tu tep matran-B.txt la:\
n"; duaRaMT(B,mB,nB);
if(nA==mB)
{
C=tichMT(A,B,mA,nA,nB);
cout<<"Ma tran tich C la:\
n"; duaRaMT(C,mA,nB);
15

ofstream fout("kt-
thctdlgtbai06.txt");
fout<<mA<<'\t'<<nB<<endl;
for(int i=1;i<=mA;i++)
{
for(int j=1;j<=nB;j++)
fout<<'\t'<<C[(i-
1)*nB+j-1];
fout<<endl;
}
cout<<"Da ghi ma tran tich C vao tep kt-
thctdlgtbai06.txt";
}
else
cout<<"2 ma tran co kich thuoc khac nhau, khong
nhan
duoc!";
cout<<endl;
return 0;
}
void docVaoMT(int* &V,int &m,int &n,const char
*tenTep)
{
ifstream fin(tenTep);
fin>>m>>n;
V=new
int[m*n];
fin>>V[(i-1)*n+j-1];

}
int* tichMT(int *V1,int *V2,int m,int p,int n)

{
int *V3=new
int[m*n]; for(int
i=1;i<=m;i++)
{
V3[(i-1)*n+j-1]=0;
for(int k=1;k<=p;k++)
V3[(i-1)*n+j-1]+=V1[(i-1)*p+k-1]*V2[(k-
1)*n+j-1];
return V3;
}
void duaRaMT(int *V,int m,int n)
16

{
{
cout<<'\t'<<V[(i-
1)*n+j-1];
cout<<endl;
}
}
Bài 07(thctdlgtbai07.cpp): Cài đặt cấu trúc dữ liệu

ngăn xếp sử dụng
một số nguyên dương hệ 10 sang hệ 2. Đưa ra bit
MSB của số nhị phân tìm được.
#include<iostream>
#include<stdio.h>
//Khai bao hang

#define N 32
//Khai bao ham cai dat cac phep toan tren
ngan xep void push(char *S,int &T,char x);
char pop(char *S,int &T);
bool isEmpty(const char
*S,int T); char top(const
char *S,int T);
//===chuong trinh
chinh=== int main()
{
//Cai dat cau truc luu tru ke tiep cua
ngan xep char S[N];
int T=-1;
//Khai bao
bien int
n,thuong,du
; char msb;
//Nhap n
cout<<"Nhap vao mot so nguyen duong: ";
17

cin>>n;
//Chuyen sang
he 2 thuong=n;
while(thuong)
{
du = thuong%2;
thuong /= 2;
//Chuyen so du thanh chu so nhi phan (bit) roi day

xe vao ngan
p
if(du) push(S,T,'1');
else push(S,T,'0');
}
//Lay bit msb cua so nhi phan tu

ngan xep msb = top(S,T);
//Dua ra so nhi phan va msb

cout<<"So nhi phan cua "<<n<<"
la: "; while(!isEmpty(S,T))
cout<<pop(S,T);
cout<<"\nBit MSB cua so nhi phan nay la: "<<msb;
cout<<endl;
return 0;
}
void push(char *S,int &T,char x)
{
//1.Kiem tra
day if(T==N-
1)
{
cout<<"Ngan xep da
day."; return;
}
//2-3.Tang T len 1 roi dua x vao ngan tai

vi tri T S[++T] = x;
}
char pop(char *S,int &T)

{
//1.Kiem tra ngan
xep rong if(T==-1)
{
18

cout<<"Ngan xep da
rong."; return 1;
}
//2-3-4.Tra ve phan tu dinh va

giam T di 1 return S[T--];
}
bool isEmpty(const char *S,int T)

{
return T==-1;
}
char top(const char *S,int T)
{
//1.Kiem tra
rong if(T==-1)
{
cout<<"Ngan xep da
rong."; return 1;
}
//Tra ve phan tu
dinh return S[T];
}

ngăn xếp sử dụng
một số nguyên dương hệ 10 sang hệ 16.
#include<iostream>
#include<stdio.h>
//Khai bao hang

#define N 8

ngan xep struct Stack
{
int T;
char
S[N];
};
19

void push(Stack &ST,char
x); char pop(Stack &ST);
bool isEmpty(Stack ST);
//===chuong trinh
chinh=== int main()
{
ngan xep Stack ST={-1};
//Khai bao
bien int
n,thuong,du
;
//Nhap n
cout<<"Nhap vao so nguyen
duong: "; cin>>n;
//Chuyen sang
he 16 thuong=n;
while(thuong)
{
du=thuong%16;
thuong /=16;
//Chuyen so du thanh chu so nhi phan (bit) roi day

xep vao ngan
if(du<10)
} push(ST,du+48); else
p ush(ST,du+55);
//Dua ra so nhi phan va msb

cout<<"So he 16 cua "<<n<<"
la: "; while(!isEmpty(ST))
cout<<pop(ST);
cout<<endl;
return 0;
}
//===dinh nghia
ham=== void
push(Stack &ST, char x)
{
//1.Kiem tra
day if(ST.T ==
N-1)
{
cout<<"Ngan xep
day."; return;
}
20

//2-3.Tang T len 1 roi dua x vao ngan tai vi
tri T ST.S[++ST.T] = x;
}
char pop(Stack &ST)
{
//1.Kiem tra ngan xep
rong if(ST.T == -1)
{
cout<<"Ngăn xếp rỗng";
return 1;
}
//2-3-4.Tra ve phan tu dinh va

giam T di 1 return ST.S[ST.T--];
}
bool isEmpty(Stack ST)

{
return ST.T==-1;
}
hàng đợi sử dụng cấu trúc lưu trữ kế tiếp theo kiểu
quay vòng với phần tử dữ liệu là số nguyên. Sử dụng
hàng đợi cho bài to 愃 Ān: Đọc vào dãy số nguyên
dương từ tệp văn bản 'daysonguyen.txt', trên tệp
không có thông tin về số phần
tử của dãy. T 愃 Āch dãy số thành dãy c 愃 Āc số chẵn và
dãy c 愃 Āc số lẻ.
#include<iostream
>
#include<stdio.h>
#include<fstream>
using namespace
std;
//Khai bao hang
#define N 50
//Khai bao kieu cau truc gop
3 bien struct Queue
{
int F, R;
int
Q[N];
};
hang doi void CQInsert(Queue &QFR,int
a);
int CQDelete(Queue
&QFR); bool
CQIsEmpty(Queue QFR);
21

//=== chuong trinh chinh===
int main ()
{
//Cai dat cau truc
luw tru Queue QFR
= {-1,-1};
//Khai bao tep vao ra
ifstream
fin("daysonguyen.txt");
ofstream
fout("daysonguyen2.txt");
//Khai bao
bien int a;
//Doc tung so tu tep

while(!fin.eof())
{
fin>>a; if(a
%2==0)
{
fout<<a<<"\t";
}
else
{
CQInsert(QFR, a);
}
}
fout<<'\n';
while (!CQIsEmpty(QFR))
{
a= CQDelete(QFR);
fout<<a<<'\t';
}
cout<<"Da luu ket qua vao tep
daysonguyen2.txt"; cout <<endl;
return 0;
}
//===Dinh nghia ham===

void CQInsert(Queue &QFR, int a)
{
if (QFR.F == 0 && QFR.R == N - 1 || QFR.R + 1 ==
QFR.F)
{
cout <<"Hang doi da
day!"; return;
}
if (QFR.R == -1)
22

QFR.F = QFR.R = 0;
else if (QFR.R == N
- 1) QFR.R = 0;
else
QFR.R++;
QFR.Q[QFR.R] = a;
}
int CQDelete (Queue &QFR)
{
int tg;
if (QFR.F == -1)
{
cout<<"Hang doi rong!";
return tg;
}
tg =
QFR.Q[QFR.F];
if (QFR.F ==
QFR.R)
QFR.F = QFR.R = -1;
else if (QFR.F == N - 1)
QFR.F=0;
else
QFR.F++;
return tg;
}
bool CQIsEmpty(Queue QFR)
{
return QFR.F == -1;
}

hàng đợi sử dụng
cấu trúc lưu trữ kế tiếp theo kiểu quay vòng. Sử
dụng hàng đợi cho bài to 愃 Ān:
Có một tệp danh s 愃 Āch sinh viên, mỗi sinh viên có
thông tin gồm mã sv, họ tên, giới tính, điểm tbc.
Danh s 愃 Āch sinh viên trên tệp đã được sắp xếp
theo điểm tbc giảm dần.
Ghi lại tệp sao cho tất cả sinh viên nữ ở đầu danh s
愃 Āch, tất cả sinh viên nam ở cuối danh s 愃 Āch,
điểm tbc vẫn giảm dần trong nhóm nam và nữ.
23

#include<iostream>
#include<stdio.h>
#include<fstream>
#include<string.h>
//Khai bao
hang #define
N 50
//Khao bao kieu struct

sinh vien struct SinhVien
{
char maSV[7];
char
hoTen[31];
char
gioiTinh[5];
float diemTBC;
};
//Khai bao kieu cau truc gop 3

bien struct Queue
{
int F, R;
SinhVien
Q[N];
};
//Khai bao ham cai dat cac phep toan
tren hang doi void CQInsert(Queue
&QFR, SinhVien x);
SinhVien CQDelete(Queue
&QFR); bool
CQIsEmpty(Queue QFR);
//===chuong trinh
chinh=== int main()
{
//Cai dat cau truc luw
tru Queue QFR = {-1,-
1};
//Khai bao tep vao ra

ifstream
fin("sinhvien.txt");
ofstream fout("sinhvien2.txt");
//Khai bao
bien int n;
SinhVien x;
//Doc so luong sv
tu tep fin>>n;
fout<<n<<endl;
24

//Doc tung sv tu tep
for(int i=0;i<n;i++)
{
fin.getline(x.maSV,
sizeof(x.maSV)); cout<<"\nTest
doc:\t"; fin.getline(x.maSV,
sizeof(x.maSV),'\t');
cout<<x.maSV;
fin.getline(x.hoTen, sizeof(x.hoTen),'\
t'); cout<<'\t'<<x.hoTen;
fin.getline(x.gioiTinh,
sizeof(x.gioiTinh),'\t'); cout<<'\
t'<<x.gioiTinh;
fin>>x.diemTBC;
cout<<'\
t'<<x.diemTBC;
if(strcasecmp(x.gioiTinh,"Nữ")==0)
{
fout<<x.maSV<<'\t'<<x.hoTen<<'\t'<<x.gioiTinh<<'\
t'<<x.diemT BC<<endl;
}
else
CQInsert(QFR, x);
cout<<"Test sau chen:

"<<QFR.Q[QFR.F].maSV; while (!
CQIsEmpty(QFR))
{
x= CQDelete(QFR);
fout<<x.maSV<<'\t'<<x.hoTen<<'\t'<<x.gioiTinh<<'\
t'<<x.diemT BC<<endl;
cout<<"\n Test xoa: "<<x.maSV<<'\
t'<<x.hoTen<<'\t'<<x.gioiTinh<<'\t'<<x.diemTBC;
}
cout<<"\nDa ghi lai danh sach sinh vien ra tep
sinhvien2.txt";
cout<<endl;
return 0;
}
void CQInsert(Queue &QFR, SinhVien x)
{
25

if (QFR.F == 0 && QFR.R == N - 1 || QFR.R + 1 ==
QFR.F)
{
cout <<"Hang doi da
day!"; return;
}
if (QFR.R == -1)
QFR.F = QFR.R = 0;
else if (QFR.R == N - 1)
QFR.R = 0;
else
QFR.R++;
QFR.Q[QFR.R] = x;
cout<<"\nTest chen: "<<x.maSV;
}
SinhVien CQDelete (Queue &QFR)

{
SinhVien tg;
if (QFR.F == -1)
{
cout<<"Hang doi
rong!"; return tg;
}
tg = QFR.Q[QFR.F];
if (QFR.F == QFR.R)
QFR.F = QFR.R =
-1;
else if (QFR.F == N - 1)
QFR.F=0;
else
QFR.F++;
cout<<"\nTest xoa:
"<<tg.maSV; return tg;
}
bool CQIsEmpty(Queue QFR)

{
return QFR.F == -1;
}
26

Bài 12(thctdlgtbai12.cpp): Cài đặt danh s 愃 Āch liên
kết đơn có phần tử dữ liệu là số nguyên, với c 愃
Ācbphép to 愃 Ān sau:
1) Bổ sung phần tử dữ liệu x vào sau nút M
2) Bổ sung phần tử dữ liệu x vào trước nút M
3) Xóa nút M
4) Duyệt danh s 愃 Āch để đưa c 愃 Āc phần tử dữ
liệu ra màn hình.
5) Tìm một nút có phần tử dữ liệu bằng x, nếu có
trả về địa chỉ nút, nếu không có trả về rỗng.
Sử dụng danh s 愃 Āch liên kết đơn P để lưu trữ dãy số
từ tệp văn bản 'daysonguyen.txt', trên tệp không
có thông tin về số phần tử của dãy số.
Tạo danh s 愃 Āch liên kết đơn Q bao gồm c 愃 Āc
phần tử dữ liệu của P nhưng theo thứ tự đảo ngược.
Xóa một nút trên DSLK đơn P mà có phần tử dữ liệu
bằng x nhập vào từ bàn phím.
#include<iostream>
#include<fstream>
#include<stdio.h>

//Khai bao kieu cau truc nut nho

cua DSLKD struct node
{
int infor;
node
*link;
};
27

//Khai bao ham cai dat cac phep toan
tren DSLKD node* SLPostInsert(node*
&F,node *M,int x); node*
SLPreInsert(node* &F,node *M,int x);
void SLDelete(node*
&F,node *M); void
SLDisplay(node *F);
node* SLSearch(node *F,int x);
//===chuong trinh
chinh=== int main()
{
DSLKD P va Q node
*P=NULL,*Q=NULL,*M;
//Khai bao tep doc vao
ifstream fin("daysonguyen.txt");
//Khai bao
bien int x;
//Doc day so tu tep dua vao
DSLKD P while(fin>>x) M =
SLPostInsert(P,M,x);
//Dua ra day so trong DSLKD P

cout<<"Day so trong DSLKD P
la:\n"; SLDisplay(P);
//Tao DSLKD Q la dao

nguoc cua P M = P;
while(M)
28

{
SLPreInsert(Q,Q,M-
>infor); M = M->link;
}
cout<<"\n\nDay so trong DSLKD Q la dao nguoc cua

P:\n"; SLDisplay(Q);
//Xoa nut trong DSLKD P co phan

tu bang x cout<<"\n\nNhap phan
tu x can xoa: "; cin>>x;
if(M=SLSearch(P,x))
{
//Xoa phan tu bang x trong
DSLKD P SLDelete(P,M);
//Dua ra DSLKD P
cout<<"\nDay so trong DSLKD P sau khi xoa phan tu
"<<x<<" la:\n";
SLDisplay(P);
}
else cout<<"\nTrong DSLKD P khong co phan tu bang
"<<x;
cout<<endl;
return 0;
}
node* SLPostInsert(node* &F,node *M,int x)
29

{
//1.Tao nut nho moi
chua x node *N = new
node;
N->infor = x;
N->link = NULL;
//2.Noi nut moi vao sau

nut M if(F==NULL) F = N;
else
{
N->link = M-
>link; M->link
= N;
}
//3.Tra ve dia chi nut moi

bo sung return N;
}
node* SLPreInsert(node* &F,node *M,int x)

{
//1.Tao nut nho moi
node;
N->infor = x;
N->link = NULL;

else if(M==F)
{
30

N->link =
M; F = N;
}
else
{
//Tim den nut P truoc
nut M node *P=F;
while(P->link != M) P = P->link;
//Noi nut moi vao giua nut

P va M P->link = N;
N->link = M;
}
//3.Tra ve dia chi nut moi

bo sung return N;
}
void SLDelete(node* &F,node *M)

{
//1.Truong hop DSLKD
rong if(F==NULL)
{
cout<<"Danh sach lien ket don da
rong."; return;
}
//2.Ngat ket noi voi nut M

if(M==F) F = F->link;
31

else
{
//Tim den nut P truoc
nut M node *P=F;
while(P->link != M) P = P->link;
//Noi nut truoc M voi

nut sau M P->link = M-
>link;
}
}
void SLDisplay(node *F)
{
node *P = F;
while(P)
{
cout<<P->infor<<"
"; P = P->link;
}
}

node* SLSearch(node *F,int x)
{
node *P = F;
//Tim nut co phan tu bang

x while(P)
if(P->infor == x)
break; else P = P-
>link;
32

//Khong tim thay, tra ve dia
chi rong return P;
}
Bài 13(thctdlgtbai13.cpp): Cài đặt và sử dụng danh s

愃 Āch liên kết đơn cho bài to 愃 Ān sau: Đọc danh s 愃
Āch sinh viên từ tệp văn bản 'sinhvien.txt' lưu vào
DSLKD, mỗi sinh viên có thông tin về mã sinh viên, họ
tên, lớp, điểm tbc. Xóa sinh viên có mã nhập vào từ
bàn phím. Tìm và đưa ra màn hình c 愃 Āc sinh viên
có điểm tbc >= 6.5.
#include<iostream>
#include<stdio.h>
#include<fstream>
using namespace
std;
//Khai bao sinh
vien struct SV
{
char
maSV[10];
char
hoTen[100];
char lop[10];
float
diemTBC;
};
cua DSLKD struct node
{
SV infor;
node
*link;
};
//Khi bao ham cai dat cac phep toan

tren DSLKD node
*SLPostInsert(node* &F,node *M,SV
x); node *SLPreInsert(node* &F,node
*M,SV x); void SLDelete(node*
&F,node *M);
void SLDisplay(node *F);
node* SLSearch(node *F,float x);
//===chuong trinh
chinh=== int main()
{
//Cai dat cau truc luu tru
cua DSLKD node
*P=NULL,*Q=NULL,*M;
33

//Khai bao tep
ifstream fin("sinhvien.txt");
//Khai bao
bien int n;
SV x;
char tg[3];
char
maSV[10];
char
hoTen[100];
char lop[10];
float
diemTBC;
//Doc so luong mat hang tu
tep fin>>n;
//Doc cac mat hang tu tep dua
vao DSLKK for(int i=0;i<n;i++)
{
}
duoi

// cuoi dong de dua con tro tep xuong dong
Doc fin.getline(tg,sizeof(tg));
ky //Doc mat hang thu i vao x

fin.getline(x.maSV,sizeof(x.maSV),'\t');
tu fin.getline(x.hoTen,sizeof(x.hoTen),'\t');
fin.getline(x.lop,sizeof(x.hoTen),'\t');
Ente fin>>x.diemTBC;
ro //Dua mat hang x vao DSLKD

M=SLPostInsert(P,M,x);
cout<<"danh sach sinh vien trong DSLKD
la\n"; SLDisplay(P);
cout<<endl;
return 0;
}
node *SLPostInsert(node* &F,node *M,SV x)
{
//1.Tao nut nho moi
node;
N->infor = x;
N->link = NULL;

else
34

{
N->link = M-
>link; M->link
= N;
}
}
node *SLPreInsert(node* &F,node *M,SV x)
{
//1.Tao nut nho moi
node;
N->infor = x;
N->link = NULL;
//2. truong hop M la nut dau

tien if(M==F)
{
N->link =
M; F = N;
}
else // M khong phai nut dau tien
{
// Tim nut truoc nut
M node *P= F;
while(P->link != M)
{
P= P->link;
}
//Noi N vao danh
sach N->link = P-
>link;
P->link = N;

}
}
void SLDelete(node* &F,node *M)

{
//kiem tra
rong
if(F==NULL)
cout<<"Danh sach
rong"; if(M==F)
F= F->link;
else
{
// Tim nut truoc nut
M node *P= F;
while(P->link != M)
35

{
P= P->link;
}
// Noi nut truoc M vs
nut sau M P->link = M-
>link;
}
//Huy
nut
delete
M;
}
void SLDisplay(node *F)
{
node *P = F;
while(P)
{
//Dua ra mat hang trong nut P
cout<<"\nMa sinh vien: "<<P-
>infor.maSV;
cout<<"\nTen sinh vien: "<<P->infor.hoTen;
cout<<"\nLop: "<<P->infor.lop;
cout<<"\nDiem trung binh cong: "<<P-
>infor.diemTBC; cout<<endl;
P = P->link;
}
}
node* SLSearch(node *F,float x)
{
node *P = F;
//Tim nut co phan tu

bang x while(P)

if(P->infor.diemTBC == x)
break; else P = P->link;
//Khong tim thay, tra ve dia chi

rong return P;
}

kép có phần tử dữ liệu là số nguyên, với các
36

phép to 愃 Ān sau:
1) Bổ sung phần tử dữ liệu x vào sau nút M
2) Bổ sung phần tử dữ liệu x vào trước nút M
3) Xóa nút M
4) Duyệt danh s 愃 Āch để đưa c 愃 Āc phần tử dữ
liệu ra màn hình từ tr 愃 Āi sang phải
và từ phải sang tr 愃 Āi.
5) Tìm một nút có phần tử dữ liệu bằng x, nếu có
trả về địa chỉ nút, nếu không có trả về rỗng.
Sử dụng danh s 愃 Āch liên kết kép để lưu trữ dãy số
từ tệp văn bản 'daysonguyen.txt', trên tệp không
có thông tin về số phần tử của dãy số.
Đưa dãy số nguyên trong DSLKK ra màn hình theo
thứ tự từ tr 愃 Āi sang phải và từ phải sang tr 愃 Āi.
Xóa tất cả c 愃 Āc nút mà có phần tử dữ liệu bằng x
nhập vào từ bàn phím.
#include<iostrea
m>
#include<fstrea
m>
#include<stdio.h
>

cua DSLKK struct node
{
int infor;
node *left,*right;
};
//Khai bao kieu cau truc gop 2

con tro L,R. struct DList
{
node *L,*R;
};
37

//Khai bao ham cai dat cac phep
toan tren DSLKK node*
DLPostInsert(DList &LR,node
*M,int x); node* DLPreInsert(DList
&LR,node *M,int x); void
DLDelete(DList &LR,node *M);
void DLDisplay(DList LR,bool
leftToRight=1); node* DLFind(DList
LR,int x);
//===Chuong trinh
chinh=== int main()
{
//Cai dat cau truc luu tru
cua DSLKK DList
LR={NULL,NULL};
//Khai bao tep vao

ifstream fin("daysonguyen.txt");
//Khai bao
bien int x;
//Doc day so tu tep dua vao

DSLKK while(fin>>x)
DLPostInsert(LR,LR.R,x);
//Dua ra day so
cout<<"Day so trong DSLKK tu trai qua phai
la:\n"; DLDisplay(LR);
cout<<"\n\nDay so trong DSLKK tu phai qua trai
la:\n"; DLDisplay(LR,0);
cout<<end
l; return 0;
}
//===Dinh nghia ham===
node* DLPostInsert(DList &LR,node *M,int x)
{
//Tao nut moi chua
phan tu x node *N
= new node;
N->infor = x;
N->left = N->right = NULL;
//Truong hop DSLKK rong

if(LR.L==NULL) LR.L = LR.R
= N;
38

else if(M==LR.R)
{
M->right = N;
N->left =
M; LR.R =
N;
}
else
{
N->right = M-
>right; M-
>right->left =
N;
M->right = N;
N->left =M;
}
//Tra ve dia chi moi

bo sung return N;
}
node* DLPreInsert(DList &LR,node *M,int x)

{
//Tao nut moi chua
phan tu x node *N
= new node;
N->infor = x;
//Noi nut moi vao truoc

nut M if(LR.L==NULL) LR.L
= LR.R = N;
else if(M==LR.L)
{
N->right
= M; M-
>left = N;
LR.L = N;
}
else
{
M->left-
>right = N; N-
>left = M-
>left; N-
>right = M;
M->left = N;
}
//Tra ve dia chi nut moi

bo xung return N;
39

}
void DLDelete(DList &LR,node *M)

{
//Truong hop
rong
if(LR.L==NULL)
{
cout<<"Danh sach da
rong!"; return;
}
//Ngat ket noi voi nut M

if(LR.L==LR.R) LR.L = LR.R = NULL; //DSLKK chi con 1
nut
else if(M==LR.L) //M la nut dau
{
LR.L = LR.L-
>right; LR.L-
>left = NULL;
}
else if(M==LR.R)
{
LR.R = LR.R-
>left; LR.R-
>right = NULL;
}
else
{
M->left->right =
M->right; M-
>right->left = M-
>left;
}
//Huy nut
M delete
M;
}
void DLDisplay(DList LR,bool leftToRight)

{
node *P = leftToRight?LR.L:LR.R;
while(P)
{
cout<<P->infor<<" ";
P = leftToRight?P->right:P->left;
}
}
40

node* DLFind(DList LR,int x)
{
node *P = LR.L;
while(P)
if(P->infor == x )
return P; else P =
P->right;
//Truong hop khong

thay return P;
}
Bài 15(thctdlgtbai15.cpp): Cài đặt và sử dụng danh s

愃 Āch liên kết kép cho bài to 愃 Ān sau: Đọc danh s 愃
Āch mặt hàng từ tệp văn bản 'mathang.txt' lưu vào
DSLKK, mỗi mặt hàng có thông tin về mã hàng, tên
hàng, số lượng, đơn gi 愃 Ā. Đưa danh s 愃 Āch mặt
hàng ra màn hình kèm theo số tiền của từng mặt
hàng và tổng số tiền của tất cả mặt hàng. Xóa mặt
hàng có mã nhập vào từ bàn phím.
#include<iostream>
#include<fstream>
#include<stdio.h>
#include<string.h>
//Khai bao kieu cau truc mat

hang struct MatHang
{
char
maHang[11];
char
tenHang[31];
int soLuong;
float gia;
};
//Khai bao cau truc nut nho cua danh sach lien ket
kep (DSLKK) struct node
{
MatHang
infor; node
*left,*right;
};
//Khai bao ham cai dat cac phep toan tren DSLKK
41

void DLLastInsert(node* &L,node*
&R,MatHang x); void DLDisplay(node*
L,node* R);
bool DLDelete(node* &L,node* &R,const char
*maHang);
//===chuong trinh
chinh=== int main()
{
DSLKK node
*L=NULL,*R=NULL;

ifstream
fin("mathang.txt");
//Khai bao
bien int n;
MatHang
x; char
tg[3];
char maHang[11];
//Doc so luong mat hang

tu tep fin>>n;
//Doc cac mat hang tu tep dua vao

DSLKK for(int i=0;i<n;i++)
{
duoi
/ Doc ky tu Enter o cuoi dong de dua con tro tep
/ xuong dong fin.getline(tg,sizeof(tg));
//Doc mat hang thu i vao x

fin.getline(x.maHang,sizeof(x.maHang),'\t');
fin.getline(x.tenHang,sizeof(x.tenHang),'\t');
fin>>x.soLuong>>x.gia;
//Dua mat hang x vao DSLKK
DLLastInsert(L,R,x);
}
//Dua ra danh sach mat hang

cout<<"Danh sach mat hang trong DSLKK la:\n";
DLDisplay(L,R);
//Xoa mat hang co ma cho truoc

cout<<"\n\nNhap vao ma mat hang
can xoa: "; cin>>maHang;
42

if(DLDelete(L,R,maHang)) cout<<"\nDa xoa mat hang
co ma la: "<<maHang;
else cout<<"\nTrong DSLKK khong co ma mat hang
la: "<<maHang;
cout<<endl;
return 0;
}
void DLLastInsert(node* &L,node* &R,MatHang x)
{
//1.Tao nut nho moi
chua x node *N =
new node;
N->infor = x;
//2.Noi nut moi vao cuoi DSLKK

(sau nut R) if(R==NULL) L = R = N;
else
{
R->right =
N; N->left
= R; R = N;
}
}
void DLDisplay(node* L,node* R)

{
node *P=L;
while(P)
{
//Dua ra mat hang trong nut P
cout<<"\nMa mat hang: "<<P-
>infor.maHang; cout<<"\nTen mat
hang: "<<P->infor.tenHang;
cout<<"\nSo luong: "<<P-
>infor.soLuong; cout<<"\nDon
gia: "<<P->infor.gia;
cout<<"\nThanh tien: "<<P->infor.soLuong*P-
>infor.gia; cout<<endl;
//Cho P tro sang nut

tiep theo P = P->right;
}
}
bool DLDelete(node* &L,node* &R,const char

*maHang)
{
43

//1.Tim nut M co ma hang bang ma hang truyen
vao qua doi so node *M = L;
while(M)
{
if(strcasecmp(M->infor.maHang,maHang)==0)
break; else M = M->right;
}
//2.DSLKK rong hoac khong tim

thay if(M==NULL) return 0;
//3.Xoa nut M co ma mat hang bang ma mat hang

can xoa
//Ngat ket noi voi
nut M if(L==R) L =
R = NULL;
else if(M==L)
{
L = L->right;
L->left = NULL;
}
else if(M==R)
{
R = R->left;
R->right = NULL;
}
else
{
M->left->right = M-
>right; M->right->left
= M->left;
}
//Huy nut
M delete M;
//Da
xoa
return
1;
}
Bài 16(thctdlgtbai16.cpp): Cài đặt ngăn xếp sử dụng

cấu trúc lưu trữ phân t 愃 Ān với phần tử dữ liệu là số
nguyên. Ứng dụng ngăn xếp cho bài to 愃 Ān tìm và
đưa ra c 愃 Āc số nguyên tố nhỏ hơn n theo thứ tự
giảm dần.
#include<iostrea
m>
#include<stdio.h
>
#include<math.h
>
44

//Khai bao cau truc nut nho

cua ngan xep struct node
{
int
infor;
node*
link;
};
//Khai bao ham cai dat phep toan

tren ngan xep void push(node*
&T,int x);
int pop(node*
&T); bool
isEmpty(node*
T);
//Khai bao ham

thong thuong bool
isPrime(int x);
//===chuong trinh
chinh=== int main()
{
//Cai dat cau truc luu tru phan tan
cua ngan xep node *T=NULL;
//Khai bao
bien int n;
//Nhap n
cout<<"Nhap vao so nguyen
duong n: "; cin>>n;
//Tim cac so nguyen to < n, tu

nho toi lon for(int i=2;i<n;i++)
if(isPrime(i))
push(T,i);
//Dua ra ket qua

cout<<"Cac so nguyen to <
"<<n<<" la:\n"; while(!isEmpty(T))
cout<<pop(T)<<" ";
cout<<end
l; return 0;
}
45

//===dinh nghia
ham=== void
push(node*
&T,int x)
{
//1.Tao nut
moi node*N =
new node; N-
>infor=x;
N->link=NULL;
//2.Noi nut moi vao

tren nut T N->link=T;
//3.Cho T tro sang

nut moi T=N;
}
int pop(node* &T)

{
//Kiem tra
rong
if(T==NULL)
{
cout<<"Ngan xep
rong."; return 1;
}
//Giu lai
nut dinh int
tg = T-
>infor;
node *P =
T;
//Cho T tro xuong

nut duoi T=T-
>link;
//Huy nut dinh va trả về phần

tử đã loại bo delete P;
return tg;
}
bool isEmpty(node* T)
{
return T==NULL;
}
bool isPrime(int x)
{
46

for(int
i=2;i<=(int)sqrt(x);i+
+) if(x%i==0) return
0;
//x la
nguyen to
return 1;
}
Bài 18(thctdlgtbai18.cpp): Cài đặt và sử dụng hàng

đợi lưu trữ phân t 愃 Ān cho bài to 愃 Ān sau: Cho
tệp văn bản 'dathuc.txt' chứa đa thức tuyến tính bậc
n. Đọc tệp, đưa ra màn hình đa thức bậc n theo
dạng Pn(x) = a0 + a1x + a2x^2 + a3x^3 +...
+ anx^n. Nhập vào x, tính Pn(x).
#include<iostrea
m>
#include<fstrea
m>
#include<stdio.h
>
#include<math.h
>

//Khai bao cau truc mot so hang gom
he so va so mu struct term
{
float
coeff;
int
power;
};
//Khai bao cau truc nut nho

cua hang doi struct node
{
term
infor;
node
*link;
};
//Khai bao cau truc gop 2

bien F va R struct Queue
{
node *F,*R;
};
//Khai bao ham cai dat cac phep toan tren hang doi
47

void QInsert(Queue &Q,
term x); term
QDelete(Queue &Q);
bool QIsEmpty(Queue Q);
//===chuong trinh
chinh=== int main()
{
//Cai dat cau truc luu tru phan tan
cua hang doi Queue
Q={NULL,NULL};
//Khai bao tep

vao ifstream
fin("dathuc.txt");
//Khai bao
bien term
t;
//Doc da thuc tu tep dua vao hang doi va

dua ra man hinh cout<<"Đa thức đọc từ tệp
là:\nP(x) = "; while(fin>>t.coeff>>t.power)
{
if(t.power==0) printf("%0.1f",t.coeff);
else printf(" + %0.1fx^
%d",t.coeff,t.power); QInsert(Q,t);
}
//Tinh P(x)
float
x,Px=0;
cout<<"\n\nNhập vào x: ";cin>>x;
while(!QIsEmpty(Q))
{
t = QDelete(Q);
Px += t.coeff*pow(x,t.power);
}
printf("P(x) = %0.1f",Px);
cout<<end
l; return 0;
}
void QInsert(Queue &Q, term x)
{
48

//1.Tao nut
moi node
*N=new
node; N-
>infor=x;
N->link=NULL;

nut R if(Q.R==NULL)
Q.F=N;
else Q.R->link=N;
//3.Cho R tro sang

nut moi Q.R=N;
}
term QDelete(Queue &Q)

{
term tg;
//1.Kiem tra
rong
if(Q.F==NULL)
{
cout<<"Hang doi da
rong!"; return tg;
}
//2.Giu lai
nut F
tg=Q.F-
>infor;
node
*P=Q.F;
//3.Cho F tro toi nut

dung sau if(Q.F==Q.R)
Q.F=Q.R=NULL;
else Q.F=Q.F->link;
//4.Huy va tra
ve nut delete
P;
return tg;
}
bool QIsEmpty(Queue Q)
{
return Q.F==NULL;
}
49

c 愃 Āc số nguyên lưu trữ trong tệp văn bản
'daykhoa.txt'. Đọc dãy khóa từ tệp vào mảng động.
Cài đặt giải thuật sắp xếp chọn để sắp xếp dãy khóa
trong mảng động tăng dần. Đưa dãy khóa ban đầu
và dãy khóa đã sắp xếp ra màn hình.
#include<iostream>
#include<fstream>
#include<stdio.h>
//Khai bao ham cai dat giai thuat sap

xep chen void selectionSort(int *a,int
n);
//===chuong trinh
chinh=== int main()
{
ifstream
fin("daykhoa.txt");
//Khai bao
bien int n;
//Doc so luong khoa tu

tep fin>>n;
//Tao mang dong a co n o nho de chua

day khoa int *a = new int;
//Doc day khoa tu mang dong vao tep
va dua ra cout<<"Day khoa ban dau doc
duoc tu tep la:\n"; for(int i=0;i<n;i++)
{
fin>>a[i];
50

cout<<a[i]<<" ";
}
//Sap xep day khoa

selectionSort(a,n);
//Dua ra
cout<<"\n\nDay khoa da sap xep tang dan
la:\n"; for(int i=0;i<n;i++) cout<<a[i]<<" ";
cout<<endl;
return 0;
}
//===dinh nghia
ham=== void
selectionSort(int *a,int
n)
{
for(int i=0;i<n-1;i++)
{
//Tim vi tri k cua khoa
nho nhat int k=i;
for(int j=i+1;j<n;j++)
if(a[j]<a[k]) k=j;
//Doi cho khoa nho nhat o vi tri k ve
vi tri i if(k!=i)
{
int
tg=a[i];
a[i]=a[k];
a[k]=tg;
}
}
}

Cài đặt giải thuật sắp xếp chèn để sắp xếp dãy khóa
trong mảng động tăng dần. Đưa dãy khóa ban đầu
và dãy khóa đã sắp xếp ra màn hình.
#include<iostream>
#include<fstream>
#include<stdio.h>
51

xep chen void insertSort(int *a,int n);
//===chuong trinh
chinh=== int main()
{
ifstream
fin("daykhoa.txt");
//Khai bao
bien int n;

tep fin>>n;

day khoa int *a = new int;

{
fin>>a[i];
cout<<a[i]<<" ";
}
//Sap xep day khoa

insertSort(a,n);
//Dua ra
cout<<endl;
return 0;
}
//===dinh nghia
ham=== void
insertSort(int *a,int
n)
{
for(int i=1;i<n;i++)
{
int tg=a[i],j=i-1;
//Tim vi tri phu hop trong day dich de

chen tg while(tg<a[j] && j>=0) a[j+1] =
a[j--];
//Chen tg vao vi tri da

tim duoc a[j+1] = tg;

}
}
Bài 26(thctdlgtbai26.cpp). Cho dãy khóa n phần tử là c
愃 Āc số nguyên lưu trữ trong tệp văn bản
Cài đặt giải thuật sắp xếp sủi bọt để sắp xếp dãy
khóa trong mảng động tăng dần. Đưa dãy khóa ban
đầu và dãy khóa đã sắp xếp ra màn hình.
#include<iostream>
#include<fstream>
#include<stdio.h>

xep chen void bubbleSort(int *a,int
n);
//===chuong trinh
chinh=== int main()
{
//Khai bao tep doc
vao ifstream
fin("daykhoa.txt");
//Khai bao
bien int n;

tep fin>>n;
//Tao mang dong a co n o nho de
chua day khoa int *a = new int[n];
//Doc day khoa tu mang dong vao tep va

dua ra cout<<"Day khoa ban dau doc duoc
tu tep la:\n"; for(int i=0;i<n;i++)
{
53

fin>>a[i];
cout<<a[i]<<"
";
}
//Sap xep day khoa
bubbleSort(a,n);
//Dua ra
cout<<endl;
return 0;
}
//===dinh nghia
ham=== void
bubbleSort(int *a,int n)
{
for(int i=0;i<n-
1;i++) for(int
j=n-1;j>i;j--)
{
if(a[j]<a[j-1])
{
int tg =a[j-
1]; a[j-
1]=a[j];
a[j]=tg;
}
}
}

愃 Āc số nguyên lưu trữ trong tệp văn bản
Cài đặt giải thuật sắp xếp nhanh để sắp xếp dãy
khóa trong mảng động tăng dần. Đưa dãy khóa ban
đầu và dãy khóa đã sắp xếp ra màn hình.
#include<iostream>
#include<fstream>
#include<stdio.h>

xep chen void quickSort(int* &a,int
L,int R);
54

//===chuong trinh
chinh=== int main()
{
ifstream
fin("daykhoa.txt");
//Khai bao
bien int n,
*a;

tep fin>>n;
//Tao mang dong a co n o nho de
chua day khoa a = new int[n];

{
fin>>a[i];
cout<<a[i]<<" ";
}
//Sap xep day

khoa
quickSort(a,0,n
-1);
//Dua ra
cout<<endl;
return 0;
}
void quickSort(int *&a,int L,int R)
{
if(L>=R) return;
int i=L, j=R, k=(L+R)/2, x=a[k];

do
{
//Duyet ben trai sang phai cho toi khi gap phan tu
>= x while(a[i]<x) i++;
//Duyet ben phai sang trai cho toi khi gap phan tu
<= x while(a[j]>x) j--;
55

//Doi cho phan tu ben trai voi phan tu
ben phai if(i<j)
{
int tg =
a[i]; a[i] =
a[j]; a[j] =
tg;
}
}
while(i<j);
//Goi de quy thuc hien phan doan

ben trai < x quickSort(a,L,j-1);
//Goi de quy thuc hien phan doan ben phai > x

quickSort(a,j+1,R);
}

愃 Āc số nguyên lưu trữ trong
tệp văn bản 'daykhoa.txt'. Đọc dãy khóa từ tệp vào
mảng động. Cài đặt giải thuật tìm kiếm tuần tự để
tìm khóa có gi 愃 Ā trị bằng x, nếu tìm thấy thì trả về
vị trí của khóa, nếu không tìm thấy thì trả về 0.
#include<iostream>
#include<fstream>
#include<stdio.h>

//Khai bao ham cai dat giai thuat tim

kiem tuan tu int sequenceSearch(int
*k,int n,int x);
//===chuong trinh
chinh=== int main()
{
ifstream
fin("daykhoa.txt");
//Khai bao
bien int n,x;
//Doc vao so phan tu cua day khoa
tu tep fin>>n;
56

day khoa int *a = new int[n];
//Doc day khoa vao mang dong a

cout<<"Day khoa doc duoc tu tep
la:\n"; for(int i=0;i<n;i++)
{
fin>>a[i];
cout<<a[i]<<" ";
}
//Tim x
cout<<"\n\nNhap khoa x can tim:
"; cin>>x;
int kq = sequenceSearch(a,n,x);
if(kq) cout<<"\nTim thay "<<x<<" trong day khoa tai

vi tri "<<kq;
else cout<<"\nKhong tim thay "<<x<<" trong day
khoa.";
cout<<endl;
return 0;
}
int sequenceSearch(int *k,int n,int x)
{
//1.Khoi
tao int
i=0;

//2. Tim kiem trong day
while(k[i] != x && i<n)
i++;
//3.Tra ve ket qua tim
kiem if(i==n) return 0;
else return i+1;
}
57

'daykhoatangdan.txt'. Đọc dãy khóa từ tệp vào mảng
động. Cài đặt giải thuật tìm kiếm nhị phân dạng
không đệ quy để tìm khóa có gi 愃 Ā trị bằng x, nếu
tìm thấy thì trả về vị trí của khóa, nếu không tìm
thấy thì trả về 0.
#include<iostream>
#include<fstream>
#include<stdio.h>
//Khai bao ham cai dat giai thuat tim kiem nhi
phan tren mang int binarySearch(int *k,int n,int
x);
//===chuong trinh
chinh=== int main()
{
ifstream fin("daykhoatangdan.txt");

//Khai bao
bien int n,x;
//Doc vao so phan tu cua day khoa

tu tep fin>>n;

day khoa int *a = new int[n];
//Doc day khoa vao mang dong a

58

cout<<"Day khoa doc duoc tu tep
la:\n"; for(int i=0;i<n;i++)
{
fin>>a[i];
cout<<a[i]<<" ";
}
//Tim x
cout<<"\n\nNhap khoa x can tim:
"; cin>>x;
int kq = binarySearch(a,n,x);
if(kq) cout<<"\nTim thay "<<x<<" trong day khoa tai

vi tri "<<kq;
else cout<<"\nKhong tim thay "<<x<<" trong day
khoa.";
cout<<endl;
return 0;
}

int binarySearch(int *k,int n,int x)
{
//1.Khoi tao
int L=0,R=n-1;
//2.Tim kiem
while(L<=R)
{
59

//Tinh chi so
giua int m =
(L+R)/2;
//So sanh
if(x<k[m]) R =
m-1;
else if(x>k[m]) L =
m+1; else return
m+1;
}
//3.Khong tim
thay return 0;
}

'daykhoa.txt'. Đọc dãy khóa từ tệp để tạo cây nhị
phân tìm kiếm. Tìm khóa có gi 愃 Ā trị bằng x, nếu
không tìm thấy thì bổ sung x vào dãy khóa.
#include<iostream>
#include<fstream>
#include<stdio.h>
//Khai bao kieu cau truc nut nho cua cay

nhi phan struct node
{
int key;
node *left,*right;
};
//Khai bao ham cai dat giai thuat tim kiem nhi
phan tren cay node* BST(node* &T,int x);
60

//===chuong trinh
chinh=== int main()
{
//Cai dat cau truc luu tru phan tan cua cay
nhi phan node *T=NULL;
cout<<endl;
return 0;
}
//===dinh nghia
ham=== node*
BST(node* &T,int x)
{
//1.Khoi tao con
tro node
*p=NULL,*q=T;
//2.Tim nut tren cay co khoa bang

x while(q)
{
if(x<q->key)
{
p = q; q = q->left;
}
else if(x>q->key)
{
p = q; q = q->right;
}
else return q;
}
//3.Bo sung x tro thanh khoa
tren cay q = new node;
q->key = x;
q->left = q->right = NULL;
if(T==NULL) T = q;
else if(x<p->key) p->left =
q; else p->right = q;
//Tra ve dia chi nut moi bo

sung return q;
}
61

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à ký tự. Sử dụng ngăn xếp để chuyển
biểu thức trung tố có dấu ngoặc đầy đủ sang dạng
hậu tố. Ví dụ: Biểu thức trung tố là ((a+b)*2) =>
Chuyển thành biểu thức hậu tố là a b + 2 *
#include<iostream>
#include<stdio.h>
//Khai bao hang

#define N 50
//Khai bao cau truc gop 2 bien S

va T struct Stack
{
int T;
char
S[N];
};

ngan xep void push(Stack &ST,char x);
char pop(Stack
&ST); bool
isEmpty(Stack ST);
//===chuong trinh
chinh=== int main()
{
ngan xep Stack ST={-1};
62

cout<<endl;
return 0;
}
//===dinh nghia
ham=== void
push(Stack &ST,char x)
{
//1.Kiem tra
day if(ST.T ==
N)
{
cout<<"Ngan xep da
day!"; return;
}
//2-3.Tang T len 1 va dua x vao

ngan xep ST.S[++ST.T] = x;
}
char pop(Stack &ST)

{
//1.Kiem tra ngan
xep rong if(ST.T==-1)
{
cout<<"Ngăn xếp đã
rỗng!"; return 1;
}
//2-3-4. Tra ve phan tu dinh va

giam T di 1 return ST.S[ST.T--];

}
bool isEmpty(Stack ST)

{
return ST.T == -1;
}
Bài 18: Lời giải
//Bai 18(thctdlgtbai18.cpp):
#include<iostream>
#include<fstream>
#include<stdio.h>
#include<string.h>
//Khai bao kieu truc sinh vien

struct SinhVien
{
char maSV[7];
char hoTen[31];
char gioiTinh[5];
float diemTBC;
};
//Khai bao cau truc nut nho cua hang doi

struct node
{
SinhVien infor;
node *link;
};
//Khai bao cua truc gop 2 bien F va R

struct Queue
{
node *F, *R;
};
//Khai bao ham cai dat cac phep toan tren hang doi
void QInsert(Queue &Q, SinhVien x);
SinhVien QDelete(Queue &Q);
bool QIsEmpty(Queue Q);
//Chuong trinh chinh
int main()
{
//Cai dat cau truc luu tru phan tan cua hang doi
Queue Q={NULL,NULL};
//Khai bao tep vao

ifstream fin("sinhvien.txt");
//Khai bao bien

int n;
SinhVien x,tg;
//Doc so luong sv tu tep va dua ra man hinh

fin>>n;
cout<<"Trong tep 'sinhvien.txt' co "<<n<<" sinh vien\n";
//Doc tung sv tu tep, neu la sv nu thi dua ra man hinh, neu la sv nam
thi dua vao hang doi
for (int i=0;i<n;i++)
{
//Doc Enter tren tep
fin.getline(x.maSV, sizeof(x.maSV));
//Doc thong tin sv

fin.getline(x.maSV, sizeof(x.maSV), '\t');
fin.getline(x.hoTen,sizeof(x.hoTen), '\t');
fin.getline(x.gioiTinh, sizeof(x.gioiTinh), '\t');
//Neu la nu thi ghi ra tep, con lai dua vao hang doi
if(strcasecmp(x.gioiTinh, "Nu") == 0)
cout<<x.maSV<<'\t'<<x.hoTen<<'\t'<<x.gioiTinh<<'\
t'<<x.diemTBC<<endl;
else
QInsert(Q,x);
}
//Lay danh sach sv nam tu hang doi dua ra man hinh
cout<<"\nDanh sach cac sinh vien nam la:\n";
tg=Q.F->infor;
while(!QIsEmpty(Q))
{
x = QDelete(Q);
cout<<x.maSV<<'\t'<<x.hoTen<<'\t'<<x.gioiTinh<<'\
t'<<x.diemTBC<<endl;
}
//Dua thong tin sv nam co diem TBC cao nhat ra man hinh
cout<<"\nSinh vien nam co diem TBC cao nhat la:\n";
cout<<tg.maSV<<'\t'<<tg.hoTen<<'\t'<<tg.gioiTinh<<'\t'<<tg.diemTBC;
cout<<endl;
return 0;
}
//==Dinh nghia ham==
void QInsert(Queue &Q, SinhVien x)
{
//1.tao nut moi
node *N=new node;
N->infor=x;
N->link=NULL;
//2.Noi nut moi vao sau nut R

if(Q.R==NULL)
Q.F=N;
else
Q.F->link=N;
//3.Cho R tro sang nut moi

Q.R=N;
}
SinhVien QDelete(Queue &Q)
{
SinhVien tg;
//1.Kiem tra rong

if(Q.F==NULL)
{
cout<<"Hang doi da rong!";
return tg;
}
//2.Giu lai nut F

tg=Q.F->infor;
node *P=Q.F;
//3.Cho F tro toi nut dung sau

if(Q.F==Q.R)
Q.F=Q.R=NULL;
else
Q.F=Q.F->link;
//4.Huy va tra ve nut

delete P;
return tg;
}
bool QIsEmpty(Queue Q)
{
return Q.F==NULL;
}
0.

0.


Tài liệu ôn tập cấu trúc dữ liệu giải thuật

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tài liệu ôn tập cấu trúc dữ liệu giải thuật

Uploaded by

Copyright:

Available Formats

Câu 1đ6: Viết chương trình C/C++ cài đặt giải thuật sắp

xếp chèn (insertSort). Áp dụng giải thuật đã cài đặt để

using namespace std;

// Hàm sắp xếp chèn

while (j >= 0 && arr[j] > key) {

Downloaded by Nghi?p ?oàn V?n (nghiepdv.k43@c3nguyendu.edu.vn)

// Đọc dãy khóa từ tệp

while (inputFile >> key) {

// Hiển thị dãy khóa ban đầu

// Áp dụng giải thuật sắp xếp chèn

using namespace std;

// Cấu trúc lưu trữ phân tán

// Cấu trúc ngăn xếp

// Hàm kiểm tra ngăn xếp có rỗng hay không

// Hàm đẩy phần tử vào ngăn xếp

// Hàm lấy và loại bỏ phần tử khỏi ngăn xếp

Node* temp = top;

// Hàm lấy phần tử đầu ngăn xếp mà không loại bỏ nó

// Hàm chuyển số nguyên dương sang số hex và ghi vào

// Chuyển đổi và đẩy ký tự hex vào ngăn xếp

// Mở tệp văn bản để ghi

// Ghi số nguyên dương và số hex vào tệp

// Chuyển đổi và ghi vào tệp

cout << "Da ghi ket qua vao tep thctdlgt-thi-

Downloaded by Nghi?p ?oàn V?n (nghiepdv.k43@c3nguyendu.edu.vn)

Câu 1đ9: Cài đặt giải thuật sắp xếp chọn

using namespace std;

// Cấu trúc mặt hàng

// Hàm sắp xếp chọn theo số lượng giảm dần

Downloaded by Nghi?p ?oàn V?n (nghiepdv.k43@c3nguyendu.edu.vn)

for (int j = i + 1; j < n; ++j) {

// Đọc danh sách mặt hàng từ tệp

// Hiển thị danh sách mặt hàng ban đầu

// Áp dụng giải thuật sắp xếp chọn

using namespace std;

// Cấu trúc thông tin thí sinh

// Cấu trúc lưu trữ phân tán

// Cấu trúc ngăn xếp lưu trữ phân tán

// Hàm băm đơn giản

// Hàm đẩy phần tử vào ngăn xếp

// Hàm lấy và loại bỏ phần tử khỏi ngăn xếp

while (table[index] == nullptr) {

Node* temp = table[index];

// Hàm kiểm tra ngăn xếp có rỗng hay không

// Đọc danh sách thí sinh từ tệp

while (inputFile >> ts.soBaoDanh >> ts.hoTen >>

// Áp dụng giải thuật sắp xếp theo điểm tăng dần

using namespace std;

// Hàm sắp xếp sủi bọt

for (int i = 0; i < n - 1; ++i) {

// Đọc số lượng phần tử n

// Kiểm tra n và hiển thị thông báo nếu dãy số trống

// Đọc danh sách dãy số từ tệp

for (int i = 0; i < n; ++i) {

// Hiển thị dãy số ban đầu

// Áp dụng giải thuật sắp xếp sủi bọt

// Hiển thị dãy số sau khi sắp xếp

Downloaded by Nghi?p ?oàn V?n (nghiepdv.k43@c3nguyendu.edu.vn)

using namespace std;

// Cấu trúc mặt hàng

// Cấu trúc danh sách liên kết đơn

// Hàm thêm một mặt hàng vào danh sách

// Hàm hiển thị danh sách mặt hàng

int* congMT(int V1,int V2,int m,int n)