IT003: Cấu trúc dữ liệu và giải thuật Ngày 11, tháng 6, năm 2022

Gợi ý ôn tập các thuật toán sắp xếp

Câu 1. Chạy từng bước thuật toán Selection Sort

1 void _selection_sort(int a[], int N) {

2 for (int i = 0; i < N - 1; ++i) {
3 int max_idx = i;
4 for (int j = i + 1; j < N; ++j)
5 if (a[j] > a[max_idx])
6 max_idx = j;
7

8 swap(a[max_idx], a[i]);
9 }
10 }

Hình 1. Hàm sắp xếp mảng một chiều giảm dần với thuật toán Selection Sort bằng ngôn ngữ C++.

Yêu cầu: Bạn hãy chạy từng bước thuật toán Selection Sort để sắp xếp mảng một chiều gồm các phần tử 3,
6, 8, 9, 7, 10 giảm dần. Thuật toán Selection Sort đã được trình bày sẵn trong Hình 1. Cụ thể, bạn hãy điền
lời giải vào Bảng 1.

a[]
Bước Chú thích
0 1 2 3 4 5
3 6 8 9 7 10
max_idx ← 5;
1 10 6 8 9 7 3
swap(a[5], a[0]);
max_idx ← 3;
2 10 9 8 6 7 3
swap(a[3], a[1]);
max_idx ← 2;
3 10 9 8 6 7 3
swap(a[2], a[2]);
max_idx ← 4;
4 10 9 8 7 6 3
swap(a[4], a[3]);
max_idx ← 4;
5 10 9 8 7 6 3
swap(a[4], a[4]);

Bảng 1. Bảng chạy từng bước thuật toán Selection Sort. Trong đó, dấu gạch chân mỗi phần tử của mảng chỉ
thị rằng phần tử đó đã được sắp xếp và sẽ không thay đổi vị trí trong các bước sắp xếp sau nữa.

Trang 1 / 7
 Câu 2. Chạy từng bước thuật toán Insertion Sort

1 void _insertion_sort(int a[], int N) {

2 for (int i = 1; i < N; ++i) {
3 int element_to_insert = a[i];
4 int j = i - 1;
5 for (; j >= 0 && a[j] < element_to_insert; --j)
6 a[j + 1] = a[j];
7 int idx_to_insert = j + 1;
8 a[idx_to_insert] = element_to_insert;
9 }
10 }

Hình 2. Hàm sắp xếp mảng một chiều giảm dần với thuật toán Insertion Sort bằng ngôn ngữ C++.

Yêu cầu: Bạn hãy chạy từng bước thuật toán Insertion Sort để sắp xếp mảng một chiều gồm các phần tử 5, 1,
10, 9, 7, 2 giảm dần. Thuật toán Insertion Sort đã được trình bày sẵn trong Hình 2. Cụ thể, bạn hãy điền lời
giải vào Bảng 2.

a[]
Bước Chú thích
0 1 2 3 4 5
5 1 10 9 7 2
element_to_insert ← 1;
1 5 1 10 9 7 2
idx_to_insert ← 1;
element_to_insert ← 10;
2 10 5 1 9 7 2
idx_to_insert ← 0;
element_to_insert ← 9;
3 10 9 5 1 7 2
idx_to_insert ← 1;
element_to_insert ← 7;
4 10 9 7 5 1 2
idx_to_insert ← 2;
element_to_insert ← 2;
5 10 9 7 5 2 1
idx_to_insert ← 4;

Bảng 2. Bảng chạy từng bước thuật toán Insertion Sort. Trong đó, dấu gạch chân mỗi phần tử của mảng chỉ
thị rằng phần tử đó đã được sắp xếp và sẽ không thay đổi vị trí trong các bước sắp xếp sau nữa.

Trang 2 / 7
 Câu 3. Chạy từng bước thuật toán Merge Sort

1 void _merge(int a[], int low, int mid, int high) {

2 int N = high - low + 1;
3 int *b = new int [N];
4 int left = low, right = mid + 1, bIdx = 0;
5 while (left <= mid && right <= high)
6 b[bIdx++] = (a[left] >= a[right]) ? a[left++] : a[right++];
7 while (left <= mid) b[bIdx++] = a[left++];
8 while (right <= high) b[bIdx++] = a[right++];
9 for (int k = 0; k < N; ++k) a[low+k] = b[k];
10 delete [] b;
11 }
12

13 void _merge_sort(int a[], int low, int high) {

14 if (low < high) {
15 int mid = (low + high) / 2;
16 _merge_sort(a, low, mid);
17 _merge_sort(a, mid + 1, high);
18 _merge(a, low, mid, high);
19 }
20 }

Hình 3. Hàm sắp xếp mảng một chiều giảm dần với thuật toán Merge Sort bằng ngôn ngữ C++.

Yêu cầu: Bạn hãy chạy từng bước thuật toán Merge Sort để sắp xếp mảng một chiều gồm các phần tử 7, 8, 9,
10, 3, 6 giảm dần. Thuật toán Merge Sort đã được trình bày sẵn trong Hình 3. Cụ thể, bạn hãy điền lời giải
vào Bảng 3.

a[]
Bước Chú thích
0 1 2 3 4 5
7 8 9 10 3 6
1 _merge_sort(a, 0, 5)
2 _merge_sort(a, 0, 2)
3 _merge_sort(a, 0, 1)
4 return 8 7 9 10 3 6
5 return 9 8 7 10 3 6
6 _merge_sort(a, 3, 5)
7 _merge_sort(a, 3, 4)
8 return 9 8 7 10 3 6
9 return 9 8 7 10 6 3
10 return 10 9 8 7 6 3

Bảng 3. Bảng chạy từng bước thuật toán Merge Sort. Trong đó, dấu gạch chân mỗi phần tử của mảng chỉ thị
rằng phần tử đó đã được sắp xếp và sẽ không thay đổi vị trí trong các bước sắp xếp sau nữa.

Trang 3 / 7
 Câu 4. Chạy từng bước thuật toán Quick Sort

1 int _partition(int a[], int low, int high) {

2 int pivot_idx = low;
3 int pivot_val = a[low];
4

5 for (int i = low + 1; i <= high; ++i)

6 if (a[i] > pivot_val)
7 swap(a[i], a[++pivot_idx]);
8

9 swap(a[low], a[pivot_idx]);
10 return pivot_idx;
11 }
12

13 void _quick_sort(int a[], int low, int high) {

14 if (low < high) {
15 int pivot_i = _partition(a, low, high);
16 _quick_sort(a, low, pivot_i - 1);
17 _quick_sort(a, pivot_i + 1, high);
18 }
19 }

Hình 4. Hàm sắp xếp mảng một chiều giảm dần với thuật toán Quick Sort bằng ngôn ngữ C++.

Yêu cầu: Bạn hãy chạy từng bước thuật toán Quick Sort để sắp xếp mảng một chiều gồm các phần tử 7, 8, 9,
10, 3, 6 giảm dần. Thuật toán Quick Sort đã được trình bày sẵn trong Hình 4. Cụ thể, bạn hãy điền lời giải
vào Bảng 4.

Trang 4 / 7
 a[]
Bước Chú thích
0 1 2 3 4 5
7 8 9 10 3 6
1 _quick_sort(a, 0, 5)
2 _partition(a, 0, 5)
3 return 3 10 8 9 7 3 6
4 _quick_sort(a, 0, 2)
5 _partition(a, 0, 2)
6 return 0 10 8 9 7 3 6
7 _quick_sort(a, 1, 2)
8 _partition(a, 1, 2)
9 return 2 10 9 8 7 3 6
10 return
11 return
12 _quick_sort(a, 4, 5)
13 _partition(a, 4, 5)
14 return 5 10 9 8 7 6 3
15 return
16 return

Bảng 4. Bảng chạy từng bước thuật toán Quick Sort. Trong đó, dấu gạch chân mỗi phần tử của mảng chỉ thị
rằng phần tử đó đã được sắp xếp và sẽ không thay đổi vị trí trong các bước sắp xếp sau nữa.

Trang 5 / 7
 Câu 5. Chạy từng bước thuật toán Heap Sort

1 void _heapify_top_down(int a[], int i, int N) {

2 int smallest, l, r;
3 while (true) {
4 l = 2 * i + 1;
5 r = l + 1;
6 if (l < N && a[l] < a[i]) smallest = l;
7 else smallest = i;
8 if (r < N && a[r] < a[smallest]) smallest = r;
9 if (smallest == i) break;
10 swap(a[i], a[smallest]);
11 i = smallest;
12 }
13 }
14

15 void _heap_sort(int a[], int N) {

16 for (int i = N / 2 - 1; i >= 0; --i)
17 _heapify_top_down(a, i, N);
18

19 for (int i = N - 1; i > 0; --i) {

20 swap(a[0], a[i]);
21 _heapify_top_down(a, 0, i);
22 }
23 }

Hình 5. Hàm sắp xếp mảng một chiều giảm dần với thuật toán Heap Sort bằng ngôn ngữ C++.

Yêu cầu: Bạn hãy chạy từng bước thuật toán Heap Sort để sắp xếp mảng một chiều gồm các phần tử 7, 8, 9,
10, 3, 6 giảm dần. Thuật toán Heap Sort đã được trình bày sẵn trong Hình 5. Cụ thể, bạn hãy điền lời giải vào
Bảng 5.

Trang 6 / 7
 a[] Cây
Bước Chú thích
0 1 2 3 4 5 Min-Heap
7

8 9

10 3 6
7 8 9 10 3 6
3

7 6

10 8 9
1 Xây dựng Min-Heap 3 7 6 10 8 9
6

7 9
i ← 5; 10 8 3
2 swap(a[0], a[5]); 6 7 9 10 8 3
_heapify_top_down(a, 0, 5);
7

8 9
i ← 4; 10 6 3
3 swap(a[0], a[4]); 7 8 9 10 6 3
_heapify_top_down(a, 0, 4);
8

10 9
i ← 3; 7 6 3
4 swap(a[0], a[3]); 8 10 9 7 6 3
_heapify_top_down(a, 0, 3);
9

10 8
i ← 2; 7 6 3
5 swap(a[0], a[2]); 9 10 8 7 6 3
_heapify_top_down(a, 0, 2);
10

9 8
i ← 1; 7 6 3
6 swap(a[0], a[1]); 10 9 8 7 6 3
_heapify_top_down(a, 0, 1);

Bảng 5. Bảng chạy từng bước thuật toán Heap Sort. Các nút trong cây Min-Heap được vẽ nét đứt chỉ thị
không thỏa tính chất của Min-Heap. Dấu gạch chân mỗi phần tử của mảng chỉ thị rằng phần tử đó đã được
sắp xếp và sẽ không thay đổi vị trí trong các bước sắp xếp sau nữa.

Hết

Trang 7 / 7