SELECTION SORT

a) Ý tưởng:
Chọn phần tử nhỏ thứ i theo thứ tự R trong danh sách A và đặt vào vị trí i của danh sách.
b) Thuật toán:
Đầu vào: A={a0, a1, .., an-1} chưa có thứ tự R
Đầu ra: A={ a0, a1, .., an-1} đã có thứ tự R
B1: Khởi i = 0 là biến chỉ mục của phần tử đầu tiên của mảng.
B2: Tìm phần tử nhỏ nhất trong mảng {ai, ai+1, .., an}.
B3: Đổi chỗ phần tử vừa tìm được với ai.
B4: Tăng i thêm 1 đơn vị.
B5: So sánh i và n, nếu i < n quay lại bước 2, nếu không kết thúc thuật toán.
Code:
void SelectionSort(int arr[], int n)
{
int i, j, min;
for (i = 0; i < n - 1; i++)
{
min = i;
for (j = i + 1; j < n; j++)
if (arr[j] < arr[min])
min = j;
swap(arr[min], arr[i]);
}
}

c) Quá trình tính toán:

Mảng A[] = { 69, 21, 49, 53, 77, 44, 88, 13, 14, 17}
69 21 49 53 77 44 88 13 14 17
i = 0, A[min] = 13
13 21 49 53 77 44 88 69 14 17
i = 1, A[min] = 14
13 14 49 53 77 44 88 69 21 17
i = 2, A[min] = 17
13 14 17 53 77 44 88 69 21 49
i = 3, A[min] = 21
13 14 17 21 77 44 88 69 53 49
i = 4, A[min] = 44
 13 14 17 21 44 77 88 69 53 49
i = 5, A[min] = 49
13 14 17 21 44 49 88 69 53 77
i = 6, A[min] = 53
13 14 17 21 44 49 53 69 88 77
i = 7, A[min] = 69
13 14 17 21 44 49 53 69 88 77
i = 8, A[min] = 77
13 14 17 21 44 49 53 69 77 88
i = 9, A[min] = 88
13 14 17 21 44 49 53 69 77 88

QUICK SORT:
a) Ý tưởng:

Quick sort chia mảng thành hai phần bằng cách so sánh từng phần tử của mảng với một phần tử
được gọi là phần tử chốt. Một mảng bao gồm các phần tử nhỏ hơn hoặc bằng phần tử chốt và
một mảng gồm các phần tử lớn hơn phần tử chốt.

Quá trình phân chia này diễn ra cho đến khi độ dài của các mảng con đều bằng 1. Với phương
pháp đệ quy ta có thể sắp xếp nhanh các mảng con. Sau khi kết thúc chương trình ta được một
mảng đã sắp xếp hoàn chỉnh.

b) Thuật toán:

Đầu vào: A={a0, a1, .., an-1} chưa có thứ tự R

Đầu ra: A={ a0, a1, .., an-1} đã có thứ tự R
B1: Khởi tạo l = 0 (phần tử đầu mảng), r = n – 1 (phần tử cuối mảng), phần tử chốt pivot =
(l+r)/2
B2: Khởi tạo i = l, j = r.
B3: So sánh A[i] và X, nếu A[i] < X thì i++, quay lại B3. Nếu không thì sang bước 4.
B4: So sánh A[j] và X, nếu A[i] > X thì j--, quay lại B4. Nếu không thì sang bước 5.
B5: So sánh i và j:
+ Nếu i < j thì đổi chỗ A[i] và A[j], i++, j--, quay lại B3.
+ Nếu i = j thì chia mảng thành 2 phần [l, j] và [I, r] sau đó thực hiện lại B1 với từng mảng.
+ Nếu i > j thì thuật toán kết thúc.
Code:
void quickSort(int arr[], int left, int right)
{
int i = left, j = right;
int tmp;
int pivot = arr[(left + right) / 2];

while (i <= j)
{
while (arr[i] < pivot)
i++;

while (arr[j] > pivot)

j--;

if (i <= j)
{
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
};

if (left < j)
quickSort(arr, left, j);

if (i < right)
quickSort(arr, i, right);
}

c) Quá trình tính toán:

Mảng A[] = { 69, 21, 49, 53, 77, 44, 88, 13, 14, 17} l = 0, r =9, pivot = 4, X = A[4] = 77
0 1 2 3 4 5 6 7 8 9
69 21 49 53 77 44 88 13 14 17

0 1 2 3 4 5 6 7 8 9
69 21 49 53 44 13 14 17 77 88

l = 0, r = 7, pivot = 3, X = A[3]
0 1 2 3 4 5 6 7
69 21 49 53 44 13 14 17

0 1 2 3 4 5 6 7
21 49 44 13 14 17 53 69

l = 0, r = 5, pivot = 2, X = A[2]
 0 1 2 3 4 5
21 49 44 13 14 17

0 1 2 3 4 5
21 13 14 17 44 49

l = 0, r = 3, pivot = 1, X = A[1]
0 1 2 3
21 13 14 17

0 1 2 3
13 21 14 17

l = 1, r = 3, pivot = 2, X = A[2]
1 2 3
21 14 17

1 2 3
14 21 17

l = 2, r = 3, pivot = 2, X =A[2]
2 3
21 17

2 3
17 21

Kết quả:
0 1 2 3 4 5 6 7 8 9
13 14 17 21 44 49 53 69 77 88
MERGE SORT
a) Ý tưởng:
Giống như Quick sort, Merge sort là một thuật toán chia để trị. Thuật toán này chia mảng cần
sắp xếp thành 2 nửa. Tiếp tục lặp lại việc này ở các nửa mảng đã chia. Sau cùng gộp các nửa đó
thành mảng đã sắp xếp.
b) Thuật toán:

Đầu vào: A={a0, a1, .., an-1} chưa có thứ tự R

Đầu ra: A={ a0, a1, .., an-1} đã có thứ tự R
B1: Khởi tạo l = 0 (phần tử đầu mảng), r = n – 1 (phần tử cuối mảng).
B2: So sánh l và r:
+ Nếu l = r, chuyển sang B4.
+ Nếu l < r, khởi tạo m = (l + r) / 2 (phần tử giữa mảng)
B3: Phân chia mảng thành 2 mảng con A1[0, m] và A2[m+1, l], thực hiện lại B1 với từng mảng.
B4: Trộn các mảng lại theo thứ tự đã phân chia, trong quá trình trộn sắp thứ tự cho các phần tử
mảng.
Code:
void merge(int* arr, int low, int high, int mid)
{
int i, j, k, c[50];
i = low;
k = low;
j = mid + 1;
while (i <= mid && j <= high)
{
if (arr[i] < arr[j])
{
c[k] = arr[i];
k++;
i++;
}
else
{
c[k] = arr[j];
k++;
j++;
}
}
while (i <= mid)
{
c[k] = arr[i];
k++;
i++;
}
while (j <= high)
{
c[k] = arr[j];
k++;
 j++;
}
for (i = low; i < k; i++)
{
arr[i] = c[i];
}
}

void merge_sort(int* arr, int low, int high)

{
int mid;
if (low < high)
{
mid = (low + high) / 2;
merge_sort(arr, low, mid);
merge_sort(arr, mid + 1, high);

merge(arr, low, high, mid);

}
}

c) Quá trình tính toán:

Mảng A[] = { 69, 21, 49, 53, 77, 44, 88, 13, 14, 17}
69 21 49 53 77 44 88 13 14 17

69 21 49 53 77 44 88 13 14 17

69 21 49 53 77 44 88 13 14 17

69 21 49 53 77 44 88 13 14 17

69 21 49 53 77 44 88 13 14 17

21 69 49 53 77 44 88 13 14 17

21 49 69 53 77 13 44 88 14 17

21 49 53 69 77 13 14 17 44 88

13 14 17 21 44 49 53 69 77 88