์ด๋ถ ํ์
๋ ์ด, ๋๋ ๋ถ์ ์จ์ ์ด๋ถ์ธ๊ฐ?
์ ๋ต, ์ด๋ถ ํ์์ ๋๊ฐ๋ก ๋๋์ด์ ํ์ํ๋ ๊ฒ์ด๋ค.
์๋ฅผ ๋ค์ด, 1๋ถํฐ 10๊น์ง ์๋ค๊ณ ์๊ฐํด๋ณด์.
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
์ฐ๋ฆฌ๊ฐ 8์ ์ฐพ์ ๋, ๋์ผ๋ก ๋ฐ๋ก ๋ณด์ด๋๊น ์์น๋ฅผ ํ์ ํ ์ ์๋ค.
ํ์ง๋ง ๋ช ๋ฒ์งธ์ ์๋๊ฐ? ๋ฐฐ์ด์ 0๋ฒ์งธ๋ถํฐ ์์ํ๋ 7๋ฒ์งธ์ ์๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
์ปดํจํฐ ๋ฐฐ์ด ์ธ๋ฑ์ค ๊ฐ๋ ์ด ์๋ ์ฌ๋๋ค์ 8๋ฒ์งธ๋ผ๊ณ ๋ตํ ๊ฒ์ด๋ค.
์ฆ, O(1) ์๊ฐ์ด๋ค.
๊ทธ๋ผ,
{1, 4, 7, 10, 12, 23, 30, 35, 100, 120} ์ด ์์ ๋, 35์ ์์น๋?
์ฐ๋ฆฌ๋ ์์์ ๊ฐ์ ์ธ์ด๊ฐ๋ฉด์ ๋ช ๋ฒ์งธ์ ์๋์ง ์ ๊ฒ์ด๋ค.
์ฆ, O(N) ์๊ฐ์ด๋ค.
100๋ง๊ฐ์ ์ซ์๊ฐ ์๋ค๋ฉด?
์ฐ๋ฆฌ๋ 100๋ง๊ฐ๋ฅผ ์ผ์ผ์ด ์ธ๋ค๊ฐ ์ง๋ฃจํด์ ํฌ๊ธฐํ๋ค.
๋ง์ฝ์ ์ฌ๋ ์ฌ๋ฌ๋ช ์ ๋์ํด์ ์ซ์๋ฅผ ์ฐพ์๋ ๋๋ค๋ฉด??
๊ฐ ์ธ์๋ค์ 100๋ง/N ์ผ๋ก ๋๋์ด ๊ฐ ์์ญ ๋ณ๋ก ์ฐพ์ผ๋ฉด ํจ์จ์ ์ผ ๊ฒ์ด๋ค.
๊ทผ๋ฐ, ๊ฐ ์ซ์๊ฐ ์ ๋ ฌ๋์ด ์์ง ์๋ค๋ฉด N์ด 100๋ง์ด ๋ ์๋ ์๋ค.
์ฆ O(N)์ด๋ ๊ฐ์ ๊ฒ์ด๋ค.
๋ง์ฝ, ์ ๋ ฌ์ด ๋์ด์๋ค๊ณ ์๊ฐํด๋ณด์. 1๋ถํฐ 100๋ง ์ค 10๋ง์ ์ฐพ์ผ๋ ค๋๋ฐ
๋ฒํธ ํ๋๋ฅผ ์ง์๋๋ฐ 30๋ง์ด๋ค.
๊ทธ๋ผ ์ ๋ ฌ๋์ด ์๊ธฐ ๋๋ฌธ์ ์ฐ๋ฆฌ๋ 1 ๋ถํฐ 30๋ง๊น์ง์ ์์ญ๋ง ์ฐพ์ผ๋ฉด ๋๋ค.
์ด๋ฒ์๋ 9๋ง์ ์ฐพ์๋ค. ๊ทธ๋ผ 9๋ง๋ถํฐ 30๋ง๊น์ง๋ง ์ฐพ์ผ๋ฉด ๋๋ค.
์ด๋ ๊ฒ ์ ๋ ฌ์ฑ์ ์ด์ฉํ๋ฉด ๋ฒํธ๋ฅผ ํ๋ ์ง์์ ๋,
๋ ํฐ ๊ฐ์ด ์๋ ์ชฝ๊ณผ ๋ ์์ ๊ฐ์ด ์๋ ์ชฝ, 2 ๊ฐ์ ์์ญ์ผ๋ก ๋๋๊ฒ ๋๋ค.
1. ์ ํํ ์ซ์๊ฐ ์ฐพ๋ ๊ฐ๋ณด๋ค ๋ ์๋ค๋ฉด ํฐ ๊ฐ์ด ์๋ ์์ญ
2. ์ ํํ ์ซ์๊ฐ ์ฐพ๋ ๊ฐ๋ณด๋ค ๋ ํฌ๋ค๋ฉด ์์ ๊ฐ์ด ์๋ ์์ญ
๋ ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋๊ฒ๋๋ ์ฑ์ง์ ์ด์ฉํ ๊ฒ์ด '์ด๋ถ ํ์'์ด๋ค.
์ด๋ป๊ฒ ๊ตฌํ ํ๋ฉด ๋ ๊น์?
์ด๋ถ ํ์์ ์๊ฒ ๋์๋ค๋ฉด ์ปดํจํฐ๊ฐ ์ดํดํ ์ ์๋๋ก ๋ช ๋ นํด์ฃผ์ด์ผ ํ๋ค.
๊ทธ๋ผ ์ปดํจํฐ๋ N๊ฐ์ ๋ฐ์ดํฐ์ ๋ํด N/2, N/4, N/8 ... O(log N)์ ์๊ฐ๋ณต์ก๋๋ก ์ํ๋ ๊ฐ์ ์ฐพ๊ฒ ๋๋ค.
๊ตฌํ ์ ๊ทผํ๊ธฐ
์์์ ๋ ์์ญ์ผ๋ก ๋๋์ด์ผ ํ๋ค. ํ ์์ญ์ ๋ ๊ฐ๋ก ๋๋๊ธฐ ๊ฐ์ฅ ์ข์ ๋ฐฉ๋ฒ์ ๋ฌด์์ผ๊น?
์ค๊ฐ์ ๊ธฐ์ค์ผ๋ก ๋๋๋ฉด ๋๋ค.
์ด ๊ธฐ์ค์ ์ ์ด๋ถ ํ์์์ mid ๊ฐ์ด๋ผ๊ณ ํ๋ค.
์ปดํจํฐ์์ ์์ด์ ๋ํ๋ด๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ด์ ์ด์ฉํ๋ฏ๋ก ์ฐ๋ฆฌ๋ ์ค๊ฐ ๊ฐ์ ์ฐพ์ ์ ์๋ค.
๋ฐฐ์ด์ ์์์ 0๋ฒ index ๋ถํฐ ๋์ n-1๋ฒ index
๋ง์ฝ n์ด 10์ด๋ผ๋ฉด, mid = (n-1) / 2 = 9 / 2 = 4 ๊ฐ ๋ ๊ฒ์ด๋ค.
1. ๋ฐฐ์ด์ด ์ค๋ฆ์ฐจ์์ด๊ณ 4๋ฒ์งธ ์ธ๋ฑ์ค ๊ฐ < key ๊ฐ ์ด๋ผ๋ฉด ์ฐ๋ฆฌ๋ 5๋ฒ์งธ ๋ถํฐ 9๋ฒ๊น์ง ์ฐพ์ผ๋ฉด ๋๋ค.
์ฆ ์์์ ์ด 5๋ฒ์ด ๋๊ณ ๋์ 9๋ฒ์ด ๋ ๊ฒ์ด๋ค.
2. ๋ฐฐ์ด์ด ์ค๋ฆ์ฐจ์์ด๊ณ 4๋ฒ์งธ ์ธ๋ฑ์ค ๊ฐ > key ๊ฐ ์ด๋ผ๋ฉด ์ฐ๋ฆฌ๋ 0๋ฒ์งธ ๋ถํฐ 3๋ฒ๊น์ง ์ฐพ์ผ๋ฉด ๋๋ค.
3. ๋ฐฐ์ด์ด ์ค๋ฆ์ฐจ์์ด๊ณ 4๋ฒ์งธ ์ธ๋ฑ์ค ๊ฐ == key ๊ฐ ์ด๋ผ๋ฉด ์ฐ๋ฆฌ๋ ์ธ๋ฑ์ค ๊ฐ์ ๋ฐํํด์ฃผ๋ฉด ๋๋ค.
์ ๊ทผ์ ๋ฐํ์ผ๋ก ์๋ฎฌ๋ ์ด์ ํด๋ณด๊ธฐ
์ ๋ ฌ๋ ์์ด์ ์ ๋ณด, ์ฐพ๋ ๊ฐ 62
1. ์์์ ํ ์ ์ ํ : start = 0, end = 11, mid = (0+11) / 2 = 5
2. 5๋ฒ์ ์์นํ ๊ฐ : 52
3. 52 < 62, s = mid + 1 = 6, e = 11, mid = (6+11) / 2 = 8
4. 8๋ฒ์ ์์นํ ๊ฐ : 61
5. 61 < 62, s = mid + 1 = 9, e = 11, mid = (9+11) / 2 = 10
6. 10๋ฒ์ ์์นํ ๊ฐ : 73
7. 73 > 62, s = 9, e = mid - 1 = 9, mid = (9+9) / 2 = 9
7. 9๋ฒ์ ์์นํ ๊ฐ : 62
8. 62 == 62, 9๋ฒ ๋ฐํ
์ฐ๋ฆฌ๊ฐ ์๊ฐํ๋๋ก ์๋ฎฌ๋ ์ด์ ์ด ์ฑ๊ณต์ ์ผ๋ก ๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
๊ตฌํ ํด๋ณด๊ธฐ
/*
authored by jihwankim
dev-dot.tistory.com
binary search
*/
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> arr = {
10, 20, 30, 40, 50, 52, 54, 60, 61, 62, 73, 89
};
int s = 0, e = arr.size() - 1;
int key = 62;
while(true) {
int m = (s+e) / 2;
if (arr[m] < key) {
s = m + 1;
}
if (arr[m] > key) {
e = m - 1;
}
if (arr[m] == key) {
cout << key << "๋ " << m+1 << "๋ฒ ์งธ์ ์์ต๋๋ค.\n";
break;
}
}
return 0;
}
์ํ๋ ๊ฒฐ๊ณผ ๊ฐ์ด ๋์จ ๊ฒ์ ํ์ธํ ์ ์๋ค.
์ถ์ฒ Thinking
1. ์ฌ๊ท๋ก ์ ๊ทผํด๋ณด๊ธฐ
2. ์ข ๋ ์ข์ ๋ฐฉ๋ฒ์ด ์๋ค๋ฉด ์๊ฐํด๋ณด๊ธฐ
'์๊ณ ๋ฆฌ์ฆ > ์๊ณ ๋ฆฌ์ฆ ์ข ๋ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[MST] ์ต์ ์คํจ๋ ํธ๋ฆฌ - ํฌ๋ฃจ์ค์นผ(Kruskal), ํ๋ฆผ(Prim) (0) | 2024.07.11 |
---|---|
[์ต๋จ๊ฒฝ๋ก] Bellman-Ford Algorithm (0) | 2024.07.06 |