1.

Phân tích thuật toán

Lý thuyết của thuật toán

Best case: giới hạn thấp hơn về chi phí.
- Được xác định bởi đầu vào dễ nhất
- Cung cấp mục tiêu cho tất cả đầu vào
Worst case: giới hạn cao hơn về chi phí.
- Được xác định bởi đầu vào khó nhất
- Cung cấp 1 sự đảm bảo cho tất cả đầu vào
Average case: chi phí mong đợi cho đầu vào ngẫu nhiên
- Cần 1 mô hình cho đầu vào ngẫu nhiên
- Cung cấp 1 cách để đoán kết quả
Example:
Truy cập mảng cho brute-force 3-SUM
Best: ~ ½ N^3
Average: ~ ½ N^3
Worst: ~ ½ N^3
So sánh cho tìm kiếm nhị phân
Best: ~ 1
Average: ~ lgN
Worst: ~ lgN
2. Linked List
a. Danh sách liên kết đơn
- Là 1 cấu trúc dữ liệu chứa 1 chuỗi các nút (node)
- Mỗi nút chứa:
 Dữ liệu nút đó
 Con trỏ tới nút tiếp theo

3. Selection sort
- Ý tưởng:
+ Trong lần lặp i, tìm chỉ số của lần truy cập đến số bé nhất bên phải nó
+ Đổi chỗ 2 phần tử
- Độ phức tạp
 Best: N^2
Average: N^2
Worst: N^2

public class Selection

{
public static void sort(Comparable[] a)
{
int N = a.length;
for (int i = 0; i < N; i++)
{
int min = i;
for (int j = i+1; j < N; j++)
if (less(a[j], a[min]))
min = j;
exch(a, i, min);
}
}
private static boolean less(Comparable v, Comparable
w)
{ return v.compareTo(w) < 0;
}
private static void exch(Comparable[] a, int i, int j)
{ Comparable swap = a[i];
a[i] = a[j];
a[j] = swap;
}
}
 4. Insertion sort
- Ý tưởng:
+ Trong lần lặp thứ i, đổi chỗ a[i] với mỗi lần truy cập tới số lớn hơn bên trái nó
- Độ phức tạp:
Best: N
Average: N^2
Worst: N^2

public class Insertion

{
public static void sort(Comparable[] a)
{
int N = a.length;
for (int i = 0; i < N; i++)
for (int j = i; j > 0; j--)
if (less(a[j], a[j-1]))
exch(a, j, j-1);
else break;
}
private static boolean less(Comparable v, Comparable
w)
{ /* as before */ }
private static void exch(Comparable[] a, int i, int j)
{ /* as before */ }
}

5. Quick sort
- Ý tưởng:
- Độ phức tạp
Best: NlogN
Average: NlogN
Worst: N^2
private static int partition(Comparable[] a, int lo, int hi)
{
int i = lo, j = hi+1;
while (true)
{
while (less(a[++i], a[lo]))
if (i == hi) break;
while (less(a[lo], a[--j]))
if (j == lo) break;
if (i >= j) break;
exch(a, i, j);
}
exch(a, lo, j);
return j;
}

public class Quick

{
private static int partition(Comparable[] a, int lo, int hi)
{ /* see previous slide */ }
public static void sort(Comparable[] a)
{
StdRandom.shuffle(a);
sort(a, 0, a.length - 1);
}
private static void sort(Comparable[] a, int lo, int hi)
{
if (hi <= lo) return;
int j = partition(a, lo, hi);
sort(a, lo, j-1);
 sort(a, j+1, hi);
}}

6. Merge sort
Average: NlogN

7. private static void merge(Comparable[] a, Comparable[]

aux, int lo, int mid, int hi)
8. {
9. for (int k = lo; k <= hi; k++)
10. aux[k] = a[k];
int i = lo, j = mid+1;
11. for (int k = lo; k <= hi; k++)
12. {
13. if (i > mid)
14. a[k] = aux[j++];
15. else if (j > hi)
16. a[k] = aux[i++];
17. else if (less(aux[j], aux[i]))
18. a[k] = aux[j++];
19. else
20. a[k] = aux[i++];
21. }

22. public class Merge

23. {
24. private static void merge(...)
25. { /* as before */ }
 26. private static void sort(Comparable[] a, Comparable[]
aux, int lo, int hi)
27. {
28. if (hi <= lo) return;
29. int mid = lo + (hi - lo) / 2;
30. sort(a, aux, lo, mid);
31. sort(a, aux, mid+1, hi);
32. merge(a, aux, lo, mid, hi);
33. }
34. public static void sort(Comparable[] a)
35. {
36. Comparable[] aux = new Comparable[a.length];
37. sort(a, aux, 0, a.length - 1);
38. }
39. }

- Cải tiến: Dùng Insertion sort cho mảng con bé

private static void sort(Comparable[] a, Comparable[] aux, int
lo, int hi)
{
if (hi <= lo + CUTOFF - 1)
{
Insertion.sort(a, lo, hi);
return; }
int mid = lo + (hi - lo) / 2;
sort (a, aux, lo, mid);
sort (a, aux, mid+1, hi);
merge(a, aux, lo, mid, hi);
}