20232 IT3011 CTDL&TT Quiz 12 Bảng băm – Hashing

1.Cho bảng băm đánh địa chỉ đóng, dùng danh sách liên kết để lưu trữ chuỗi đụng độ
Đâu là giá trị phù hợp cần điền vào chỗ trống

#define SIZE 997

// Định nghĩa cấu trúc của một nút trong danh sách liên kết
struct Node {
int key;
int data;
struct Node* next;
};

// Hàm tính hàm băm

int hashFunction(int key) {
return key % SIZE;
}

// Hàm thêm một phần tử vào bảng băm

void insert(struct Node** hashTable, int key, int data) {
int hashIndex = hashFunction(key);
struct Node* newNode = createNode(key, data);
// Nếu vị trí đã được sử dụng, thêm phần tử vào danh sách liên kết
if (A) {
hashTable[hashIndex] = newNode;
} else {
B = hashTable[hashIndex];
hashTable[hashIndex] = C;
}
}

 A: hashTable[hashIndex] == NULL
 A: hashTable[hashIndex]->next == NULL
 B: newNode
 B: newNode->next
 C : newNode
 C: newNode->next
 C: NULL

2.Trong Java 8, bảng băm được cài đặt dùng đánh địa chỉ đóng + mảng các cây cân bằng (R-B tree)
để xử lý đụng độ. Ưu điểm của cách này so với việc dùng 1 cây AVL hoặc R-B đơn là gì?
 Thời gian tìm kiếm trung bình cỡ O(1) thay vì O(logn)
 Tiết kiệm bộ nhớ hơn so với dùng một cây R-B
 Nếu số lượng phần tử càng lớn thì thời gian tìm kiếm bằng R-B tree càng tồi hơn bảng
băm
 Luôn đảm bảo cận thời gian trong trường hợp tồi nhất trên bảng băm là O(logn)
 Có thể duyệt và in ra danh sách theo thứ tự như với cây nhị phân tìm kiếm cân bằng
3.Cho bảng băm đánh địa chỉ đóng, dùng danh sách liên kết để lưu trữ chuỗi đụng độ
Đâu là giá trị phù hợp cần điền vào chỗ trống

#define SIZE 997

// Định nghĩa cấu trúc của một nút trong danh sách liên kết
struct Node {
int key;
int data;
struct Node* next;
};

// Hàm tính hàm băm

int hashFunction(int key) {
return key % SIZE;
}

// Hàm tìm kiếm một phần tử trong bảng băm

struct Node* search(struct Node** hashTable, int key) {
int hashIndex = hashFunction(key);
struct Node* temp = A;
while (B) {
if (temp->key == key) {
return temp;
}
temp = temp->next;
}
return C; // Không tìm thấy
}

 A: hashTable[hashIndex]
 A: hashTable[0]
 B: temp->next != NULL
 B: temp != NULL
 C : NULL
 C: 1
 C: -1

4.Trong các kỹ thuật sau của đánh địa chỉ mở, đâu là kỹ thuật tránh được việc tạo cụm sơ cấp/thứ
cấp tốt nhất
 Dò tuyến tính
 Dò bậc hai
 Băm kép
 Băm lại – rehasing

5.Cho bảng băm đánh địa chỉ mở, dùng phương pháp băm kép để xử lý đụng độ
Đâu là giá trị phù hợp cần điền vào chỗ trống

#define SIZE 10
#define PRIME 7
// Định nghĩa cấu trúc của một phần tử trong bảng băm
struct Node {
int key;
int data;
int isDeleted; // Cờ đánh dấu phần tử đã bị xóa
};

// Hàm tạo một phần tử mới

struct Node* createNode(int key, int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
if (newNode == NULL) {
printf("Memory allocation failed!\n");
exit(1);
}
newNode->key = key;
newNode->data = data;
newNode->isDeleted = 0;
return newNode;
}

// Hàm tạo bảng băm và khởi tạo

struct Node** createHashTable() {
struct Node** hashTable = (struct Node**)malloc(SIZE * sizeof(struct Node*));
if (hashTable == NULL) {
printf("Memory allocation failed!\n");
exit(1);
}
// Khởi tạo các phần tử của bảng băm là NULL
for (int i = 0; i < SIZE; i++) {
hashTable[i] = NULL;
}
return hashTable;
}

// Hàm tính hàm băm chính

int hashFunction1(int key) {
return key % SIZE;
}

// Hàm tính hàm băm phụ

int hashFunction2(int key) {
return PRIME - (key % PRIME);
}

// Hàm thêm một phần tử vào bảng băm

void insert(struct Node** hashTable, int key, int data) {
int hashIndex = hashFunction1(key);
int stepSize = hashFunction2(key);

// Sử dụng phương pháp băm kép để xử lý đụng độ

while (A && !B) {
hashIndex = (C) % SIZE;
 }

if (hashTable[hashIndex] != NULL && hashTable[hashIndex]->isDeleted) {

free(hashTable[hashIndex]);
}

hashTable[hashIndex] = createNode(key, data);

}

 A: hashTable[hashIndex] != NULL
 A: hashTable[hashIndex+1] != NULL
 B: hashTable[hashIndex]->isDeleted
 B: hashTable[hashIndex]->isDeleted==0
 C : hashIndex + stepSize
 C: hashIndex + stepSize * i

6.So với bảng băm đánh địa chỉ mở thì bảng băm đánh địa chỉ đóng
 Tốn bộ nhớ hơn
 Có thể lưu trữ số lượng phần tử lớn
 Không bị ảnh hưởng nhiều bởi hàm băm
 Thời gian tìm kiếm nhanh hơn
 Tiết kiệm bộ nhớ hơn
 Xóa phần tử đơn giản hơn
 Mở rộng bảng đơn giản hơn
 Dễ dàng cài đặt hơn

7.Cho hàm tìm đoạn con dài nhất chứa các phần tử không trùng lặp bằng C++ sau
Đâu là khẳng định đúng

int longestUniqueSubarray(int arr[], int n) {

int visited[1001];
memset(visited, 0, sizeof(visited));

int start = 0, end = 0;

int maxLength = 0;

while (end < n) {

if (visited[arr[end]] == 0) {
visited[arr[end]] = 1;
end++;
if (end - start > maxLength) {
maxLength = end - start;
}
} else {
visited[arr[start]] = 0;
start++;
}
}

return maxLength;
}
Hàm trên chỉ chạy đúng nếu giá trị các phần tử trong khoảng 0-1000
Hàm trên chỉ chạy đúng nếu số lượng các phần tử trong khoảng 0-1000
Độ phức tạp tính toán của hàm trên là O(n)
Độ phức tạp tính toán của hàm trên là O(n^2)
Độ phức tạp tính toán của hàm trên là O(nlogn)

8.Đâu là nhược điểm của bảng băm dùng phương pháp dò

 không sử dụng hết ô nhớ trong mảng để lưu trữ phần tử
 cài đặt phức tạp vì mất thêm việc đánh dấu ô khi xóa
 thời gian tìm kiếm chậm hơn so với đánh địa chỉ đóng
 khi hệ số nạp tăng thì hiệu năng của các thao tác kém đi rõ rệt
 mất thêm thời gian co/giãn bảng băm

9.Tại sao trong phương pháp đánh địa chỉ mở, ô bị xóa chỉ được đánh dấu chứ không được xóa
trắng
 vì sẽ làm đứt gãy chuỗi dò khi tìm kiếm
 vì xóa trắng mất thêm thời gian ghi đè
 vì chỉ cần đánh dấu cho nhanh, giảm thời gian xóa
 không có phương án nào ở trên là đúng

10.Cho bảng băm đánh địa chỉ mở, dùng phương pháp băm kép để xử lý đụng độ
Đâu là giá trị phù hợp cần điền vào chỗ trống

#define SIZE 10
#define PRIME 7

// Định nghĩa cấu trúc của một phần tử trong bảng băm
struct Node {
int key;
int data;
int isDeleted; // Cờ đánh dấu phần tử đã bị xóa
};

// Hàm tạo một phần tử mới

struct Node* createNode(int key, int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
if (newNode == NULL) {
printf("Memory allocation failed!\n");
exit(1);
}
newNode->key = key;
newNode->data = data;
newNode->isDeleted = 0;
return newNode;
}

// Hàm tạo bảng băm và khởi tạo

struct Node** createHashTable() {
struct Node** hashTable = (struct Node**)malloc(SIZE * sizeof(struct Node*));
if (hashTable == NULL) {
 printf("Memory allocation failed!\n");
exit(1);
}
// Khởi tạo các phần tử của bảng băm là NULL
for (int i = 0; i < SIZE; i++) {
hashTable[i] = NULL;
}
return hashTable;
}

// Hàm tính hàm băm chính

int hashFunction1(int key) {
return key % SIZE;
}

// Hàm tính hàm băm phụ

int hashFunction2(int key) {
return PRIME - (key % PRIME);
}

// Hàm xóa một phần tử khỏi bảng băm

void delete(struct Node** hashTable, int key) {
int hashIndex = hashFunction1(key);
int stepSize = hashFunction2(key);
int startIdx = hashIndex;

// Duyệt qua các vị trí trong bảng băm cho đến khi tìm được phần tử cần xóa hoặc quay lại vị trí
ban đầu
while (A) {
if (B && !hashTable[hashIndex]->isDeleted) {
C; // Đánh dấu phần tử đã bị xóa
return;
}
hashIndex = (hashIndex + stepSize) % SIZE;
if (hashIndex == startIdx) {
break; // Đã duyệt qua tất cả các vị trí
}
}
printf("Key %d not found for deletion!\n", key);
}

 A: hashTable[hashIndex] != NULL
 A: hashTable[hashIndex+1] != NULL
 B: hashTable[hashIndex]->key == key
 B: hashTable[hashIndex]->key != key
 C : hashTable[hashIndex]->isDeleted = 1
 C: hashTable[hashIndex]->isDeleted = 0
11.Bảng băm dùng đánh địa chỉ mở và dò tuyến tính với hàm băm là kích thước bảng băm h=k%10
Khi thêm lần lượt khóa sau vào thì kết quả sẽ là

12, 10, 22, 8, 13, 32

Chỉ số bắt đầu từ ô số 0

X là ô chưa có giá trị
 |10|X|12|13|32|X|X|X|8|X|
 |10|X|12|32|13|22|X|X|8|X|
 |10|X|32|13|12|22|X|X|8|X|
 |10|X|12|13|22|X|X|X|8|32|
 |10|X|12|22|13|32|X|X|8|X|

12.Đâu là khẳng định đúng về bảng băm

 Bảng băm lưu trữ và tìm kiếm dựa trên bản thân giá trị của khóa
 các thao tác trên bảng băm trung bình cỡ O(1)
 thao tác tìm kiếm tồi nhất cỡ O(n)
 không có bảng băm tốt cho mọi loại dữ liệu
 Thao tác trên bảng băm luôn có thời gian O(1)

13.Trong các phương pháp xây dựng hàm băm sau, phương pháp nào phân phối các khóa kém nhất
 phương pháp cắt bỏ
 phương pháp gấp
 chia module
 phương pháp nhân

14.Trong phương pháp xử lý đụng độ nào ta ít bị ảnh hưởng bởi hàm băm, tỉ lệ nạp của bảng băm
 đánh địa chỉ mở
 đánh địa chỉ đóng
 băm kép
 băm lại

15.Cho đoạn code tìm phần tử có tần số xuất hiện lớn nhất trong dãy dùng C++ sau

void findMostFrequent(const vector<int>& arr) {

unordered_map<int, int> frequency;

// Đếm tần số các phần tử trong mảng

for (int num : arr) {
frequency[num]++;
}

// Tìm tần số xuất hiện lớn nhất

int maxFrequency = 0;
for (const auto& entry : frequency) {
if (entry.second > maxFrequency) {
maxFrequency = A;
}
}

cout << "Tần số của phần tử xuất hiện nhiều nhất là: " << maxFrequency << endl;
}

 Độ phức tạp tính toán là O(n)

 Độ phức tạp tính toán là O(nlogn)
 A : entry.second
 A : entry.first

16.Cho bảng băm đánh địa chỉ mở, dùng phương pháp dò tuyến tính để xử lý đụng độ
Đâu là giá trị phù hợp cần điền vào chỗ trống

#define SIZE 997

#define DELETED_VALUE 999999999

// Định nghĩa cấu trúc của một phần tử trong bảng băm
struct Node {
int key;
int data;
};

// Hàm tính hàm băm

int hashFunction(int key) {
return key % SIZE;
}

// Hàm tìm kiếm một phần tử trong bảng băm

struct Node* search(struct Node** hashTable, int key) {
int hashIndex = hashFunction(key);
while (A) {
if (B) {
return hashTable[hashIndex];
}
hashIndex = C;
}
return NULL; // Không tìm thấy
}

// Hàm xóa một phần tử khỏi bảng băm

void delete(struct Node** hashTable, int key) {
int hashIndex = hashFunction(key);
while (hashTable[hashIndex] != NULL) {
if (hashTable[hashIndex]->key == key) {
hashTable[hashIndex] = D ; // Đánh dấu phần tử đã bị xóa
return;
}
hashIndex = (hashIndex + 1) % SIZE;
}
printf("Key %d not found for deletion!\n", key);
}

 A: hashTable[hashIndex] != NULL
  A: hashTable[hashIndex+1] != NULL
 B: hashTable[hashIndex]->key == key
 B: hashTable[hashIndex].key == key
 C : (hashIndex + 1) % SIZE
 C: hashIndex + 1
 D :DELETED_VALUE
 D: -1
 D:0

17.Trong phương pháp xử lý đụng độ dùng đánh địa chỉ đóng - chaining, các khóa bị đụng độ có
thể được lưu trữ dùng
 danh sách liên kết đơn
 mảng kích thước biến đổi
 cây tìm kiếm nhị phân cân bằng
 mảng cố định phần tử

18.Bảng băm dùng băm kép có vấn đề gì?

 Tiết kiệm bộ nhớ hơn so với các bảng băm dùng kỹ thuật khác
 Tăng thời gian tính toán, tìm kiếm
 Chọn hàm băm thứ 2 không tốt có thể dẫn tới phân phối các khóa không đều
 Nếu kích thước dữ liệu thay đổi thường xuyên sẽ dễ gây ra hiện tượng phân mảnh bộ nhớ,
giảm hiệu suất

19.Cho bảng băm đánh địa chỉ mở, dùng phương pháp dò tuyến tính để xử lý đụng độ
Đâu là giá trị phù hợp cần điền vào chỗ trống

#define SIZE 997

#define DELETED_VALUE 999999999

// Định nghĩa cấu trúc của một phần tử trong bảng băm
struct Node {
int key;
int data;
};

// Hàm tính hàm băm

int hashFunction(int key) {
return key % SIZE;
}

// Hàm tạo bảng băm và khởi tạo

struct Node** createHashTable() {
struct Node** hashTable = (struct Node**)malloc(SIZE * sizeof(struct Node*));
if (hashTable == NULL) {
printf("Memory allocation failed!\n");
exit(1);
}
// Khởi tạo các phần tử của bảng băm là NULL
for (int i = 0; i < SIZE; i++) {
hashTable[i] = A;
}
return hashTable;
}

// Hàm thêm một phần tử vào bảng băm

void insert(struct Node** hashTable, int key, int data) {
int hashIndex = hashFunction(key);
// Nếu vị trí đã được sử dụng, sử dụng phương pháp dò tuyến tính để tìm vị trí tiếp theo trống
while (B) {
hashIndex = C;
}
hashTable[hashIndex] = createNode(key, data);
}

 A: NULL
 A: -1
 B: (hashTable[hashIndex])->key != key
 B: hashTable[hashIndex] != NULL
 C : (hashIndex + 1) % SIZE
 C: hashIndex + 1

20.Nếu bạn cần 1 cấu trúc dữ liệu hỗ trợ các việc sau
+ Thêm/xóa dễ dàng
+ Tìm kiếm các phần tử theo khóa nhanh nhất có thể
+ Dễ dàng tìm và trả về phần tử lớn nhất/nhỏ nhất trong dãy
+ Số lượng phần tử từ 10000-1tr
CTDL nào phù hợp nhất
 Cây nhị phân tìm kiếm cân bằng AVL/R-B Tree
 Mảng + tìm kiếm nhị phân
 Bảng Băm