κ°λ
λ¬Έμ μ μ λ ₯ μ¬λ‘λ₯Ό λ κ° μ΄μμ μμ μΌμ΄μ€λ‘ λΆν ν ν λΆν ν μ λ ₯μ λ΅μ λ°λ‘ ꡬν μ μλ€λ©΄ μλ λ¬Έμ μ λ΅μ λΆν λ‘ μ»μ λ΅λ€μ ν΅ν΄ ꡬν μ μλ λ°©μ. μμ μ λ ₯ μ¬λ‘μ ν΄λ΅μ νμ μ λ ₯ μ¬λ‘ ν΄λ΅μ μ΄μ©ν΄ ꡬνκΈ° λλ¬Έμ νν₯μ(top-down) νμ΄ λ°©μμ μνλ€.
μμ
1) μ΄λΆνμ
10 | 12 | 15 | 16 | 18 | 20 | 25 | 27 | 42 | 43 |
μ΄λΆνμμ μ¬μ©νλ €λ©΄ λ°°μ΄μ΄ μ΄λ―Έ μ λ ¬λ μνμ¬μΌ νλ€. μμ κ°μ λ°°μ΄μμ 27μ΄ λ°°μ΄ μμ μλμ§ νμΈνλ€κ³ κ°μ νμ.
β [λΆν ] κ°μ΄λ°μ μμΉν μμλ₯Ό κΈ°μ€μΌλ‘ λ°°μ΄μ λλκ³ μ°Ύλ κ°μ΄ κ°μ΄λ° μμλ³΄λ€ μμΌλ©΄ μΌμͺ½ λ°°μ΄, ν¬λ©΄ μ€λ₯Έμͺ½ λ°°μ΄μ μ ν
β‘ [μ 볡] β μμ μ νν λΆλΆμ μ°Ύκ³ μ νλ κ°μ΄ μλμ§ μ¬κ·μ μΌλ‘ μ΄λΆ κ²μ
β’ [λ³ν©] β‘μμ μ»μ λ΅μΌλ‘ μ 체μ λν λ΅ λμΆ
cf. μ¬κ·λ₯Ό λΆν μ 볡μΌλ‘ ꡬνν κ²½μ° κ³ λ €ν΄μΌ ν μ¬ν
- λΆν ν μ¬λ‘μ λ΅μΌλ‘λΆν° μ 체 μ λ ₯ μ¬λ‘μ λ΅μ ꡬνλ λ°©λ² κ³ μνκΈ°
- μ’ λ£ μ‘°κ±΄ μ νκΈ°
- μ’ λ£ μ‘°κ±΄μ λ§μ‘±ν κ²½μ° λ΅μ ꡬνλ λ°©μ μ νκΈ°
μ¬κ·λ‘ ꡬνν μ΄λΆνμ(CμΈμ΄)
int binarySearch(int arr[], int low, int high, int target) {
// λ°°μ΄μ μΈλ±μ€ κ°
int mid;
if (low > high) {
return 0;
}
else {
mid = (low + high) / 2;
if (arr[mid] == target) {
return mid;
}
else if (arr[mid] < target) {
return binarySearch(arr, mid + 1, high, target);
}
else {
return binarySearch(arr, low, mid - 1, target);
}
}
}
2) ν©λ³μ λ ¬(merge sort)
νλμ λ°°μ΄μ λ κ°μ λ°°μ΄λ‘ λλμ΄ μ λ ¬ μνλ₯Ό μ μ§νλ©΄μ ν©μ³ μμλλ‘ μ λ ¬λ ν κ°μ μ΅μ’ μ μΈ λ°°μ΄μ μ»λ μ μ°¨μ΄λ€. λ°°μ΄μ κΈΈμ΄κ° 1μ΄ λ λκΉμ§ λΆν μ λ°λ³΅νλ©°, Nκ°μ μμλ₯Ό κ°μ§ λ°°μ΄μ ν©λ³μ λ ¬ κ³Όμ μ μλμ κ°λ€.
β [λΆν ] λ°°μ΄μ λ°μΌλ‘ λΆν (λΆν λ λ°°μ΄μ μμλ κ°κ° N/2κ°)
β‘ [μ 볡] λΆν ν λ°°μ΄μ κ°κ° λ°λ‘ μ λ ¬(λ°°μ΄μ μμκ° 2κ° μ΄μμ΄λ©΄ ν©λ³μ λ ¬μ μ¬κ· νΈμΆνμ¬ μ λ ¬)
β’ [λ³ν©] μ λ ¬ν λ λ°°μ΄μ ν©μΉκΈ°
ν©λ³μ λ ¬ ꡬν(CμΈμ΄)
// μ λ ¬λ μνμ λΆλΆ λ°°μ΄μ ν©λ³νλ ν¨μ
void merge(int array[], int left, int right) {
int i, j, k;
int mid = (left + right) / 2;
i = left;
j = mid + 1;
k = left;
// μ΄μν μμλΌλ¦¬ λΉκ΅νλ©° λ°°μ΄ μ λ ¬ λ° μ½μ
while (i <= mid && j <= right) {
if (array[i] <= array[j]) {
res[k] = array[i];
i++;
}
else {
res[k] = array[j];
j++;
}
k++;
}
// λ¨μμλ κ°λ€μ μΌκ΄ 볡μ¬
if (i > mid) {
for (int l = j; l <= right; l++) {
res[k] = array[l];
k++;
}
}
else {
for (int l = i; l <= mid; l++) {
res[k] = array[l];
k++;
}
}
// μμ λ°°μ΄μ λ€μ΄μλ κ°λ€μ μλ λ°°μ΄λ‘ 볡μ¬
for (int l = left; l <= right; l++) {
array[l] = res[l];
}
}
void mergeSort(int arr[], int l, int r) {
int mid;
if (l < r) {
mid = (l + r) / 2; // νλμ λ°°μ΄μ λκ°λ‘ κ· λ± λΆν
mergeSort(arr, l, mid); // μ€κ° μΈλ±μ€ κΈ°μ€ μ’μΈ‘ λ°°μ΄
mergeSort(arr, mid + 1, r); // μ€κ° μΈλ±μ€ κΈ°μ€ μ°μΈ‘ λ°°μ΄
merge(arr, l, r); // μ λ ¬λ λΆλΆ λ°°μ΄λ€μ ν©λ³
}
}
ν©λ³μ λ ¬ μ½λ μ€ν κ²°κ³Ό
'Computer Science > DS & Algorithm' μΉ΄ν κ³ λ¦¬μ λ€λ₯Έ κΈ
Shortest Path Algorithm: 벨λ§-ν¬λ μκ³ λ¦¬μ¦ (0) | 2024.11.25 |
---|---|
Linear Data Structure: μ€ν, ν, λ± (0) | 2021.07.04 |
Divide and Conquer: λΆν μ 볡 - ν΅ μ λ ¬ (0) | 2021.04.18 |
Greedy: νμλ² (0) | 2021.02.23 |
[μ’ λ§λΆ] μκ³ λ¦¬μ¦ μ€κ³ ν¨λ¬λ€μ - 무μνκ² νκΈ° (0) | 2020.11.07 |