Binary-Search
๐ซ Binary-Search
์ด์งํ์, ์ด๋ถํ์.
์ ๋ ฌ๋ ๋ฆฌ์คํธ์ ๋ํด, ํน์ ์์๋ฅผ Log N ์์ ์ฐพ์๋ด๋ ์๊ณ ๋ฆฌ๋ฌ
๐ซ Use
- ์ ํ๋ฒํธ๋ถ์์ ์ด๋ฆ์ด K๋ก ์์ํ๋ ์ฌ๋์ ๋ฒํธ ์ฐพ๊ธฐ
- ์ฑ
ํ๊ฐ์ด๋ฐ๋ฅผ ํผ์น๊ณ ์ฐพ๊ธฐ ์์ํ๋ ๋ฐฉ๋ฒ
- ์ํ๋ฒณ ์์๋๋ก๋ผ๋ฉด ์ค๊ฐ์ฏค์ K๋ก ์์ํ๋ ์ด๋ฆ์ด ์์ ํ ๋๊น
- ์ฑ
ํ๊ฐ์ด๋ฐ๋ฅผ ํผ์น๊ณ ์ฐพ๊ธฐ ์์ํ๋ ๋ฐฉ๋ฒ
- ์ฌ์ ์์ ๋จ์ด ์ฐพ๊ธฐ
- ํ์ด์ค๋ถ์ ๋ก๊ทธ์ธํ๊ธฐ (ํ์ด์ค๋ถ์ด ๋ด ๊ณ์ ์ด ์ค์กดํ๋ ๊ณ์ ์ธ์ง ํ์ธํ๊ธฐ ์ํด ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์์ด๋ ์ฐพ๊ธฐ)
๐ซ ์ Why
Updown ๊ฒ์.
์ฒ์๋ถํฐ ๋๊น์ง ์ซ์ ํ๋ํ๋ ์์๋๋ก ๊ฒ์ฆํ๋ ๊ฒ ๋ณด๋ค๋, ๋ ์ข์ ๋ฐฉ๋ฒ.
ํ์ | ์๊ฐ | ์ค๋ช |
---|---|---|
์ ํํ์ | O(n) | ๋ฆฌ์คํธ์ ์ฒ์๋ถํฐ ๋๊น์ง ์์ฐจ์ ์ผ๋ก ํ์ |
์ด์งํ์ | O(log n) | ์ ๋ ฌ๋ ๋ฆฌ์คํธ์์ ํ์ ๋ฒ์๋ฅผ ์ ๋ฐ์ฉ ์ค์ฌ๊ฐ๋ฉฐ ํ์ |
- ๋ฆฌ์คํธ์ ์ซ์ N๊ฐ ์๋ค๋ฉด
- ์ ํํ์: ์ต์ ์ ๊ฒฝ์ฐ N๊ฐ์ ์ซ์๋ฅผ ๋ชจ๋ ํ์ธํด์ผ ํจ.
- ์ด์งํ์: ์ต์ ์ ๊ฒฝ์ฐ logN๋ง ํ์ธํ๋ฉด ๋จ.
- if N = 1,024
- ์ ํํ์: ์ต์ ์ ๊ฒฝ์ฐ 1,024
- ์ด์งํ์: ์ต์ ์ ๊ฒฝ์ฐ log21,024 = 10
๐ซ ๊ตฌํ
๐ซง ์ฐพ๋ ๊ฐ์ด ํ๋
low/high (or start/end).
์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ํฌํจ๋์ด ์์ ๊ฑฐ๋ผ๊ณ ์์ํ๋ ๋ฒ์.
(๊ฐ์ด ๋ฆฌ์คํธ ์์ฒด์ ์์ ์๋ ์๊ธฐ ๋๋ฌธ์ ์์ ๋ฒ์)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int binarySearch(int arr[], int target, int size)
{
// ์ฒ์์๋ ๋ชจ๋ ๋ฒ์๋ฅผ ํ์
int low = 0;
int high = size - 1;
// ์๋ก ์์น๊ฐ ์ญ์ ๋๋ฉด, ์์ ๋ฒ์๊ฐ ์๋ค๋ ๊ฒ.
while (low <= high)
{
// ์ ๋ฐ์ฉ ๋ฒ์๋ฅผ ์ค์ฌ ๋๊ฐ๋
// ํ์์ผ ๊ฒฝ์ฐ์๋ ๋ด๋ฆผ
int mid = (low + high) / 2;
if (arr[mid] == target)
return mid;
else if (arr[mid] < target)
low = mid + 1;
else
high = mid - 1;
}
return -1;
}
๐ซง ์ฐพ๋ ๊ฐ์ด ์ฌ๋ฌ ๊ฐ
์ด๋ถ ํ์ ํ ์ฐพ์ ์์น์์ ์ ์์ผ๋ก ํ์ฅํด๋ ๋์ง๋ง,
์ต์
์ ๊ฒฝ์ฐ O(N)์ด ๋ ์ ์์. (์ ๋ถ ๋ค ๊ฐ์ ๊ฐ์ผ ๊ฒฝ์ฐ)
๋์ ,
๊ฐ์ฅ ๋ง์ง๋ง์ ๋์ค๋ ๊ฐ์ ์ธ๋ฑ์ค - ๊ฐ์ฅ ๋จผ์ ๋์ค๋ ๊ฐ ์ธ๋ฑ์ค + 1 = ๊ฐ์
๋ค๋ฅด๊ฒ ์๊ฐํ๋ฉด,
์ฐพ๊ณ ์ ํ๋ ๊ฐ์ ์ฝ์
ํ์ ๋ ์ค๋ฆ์ฐจ์์ด ์ ์ง๋๋ ์์น๋ฅผ ์ฐพ๋ ๊ฒ.
์ค๋ฆ์ฐจ์์ด ์ ์ง๋๋ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์์น - ์ค๋ฆ์ฐจ์์ด ์ ์ง๋๋ ๊ฐ์ฅ ์ผ์ชฝ ์์น = ๊ฐ์
๊ฐ์ฅ ๋จผ์ ๋์ค๋ ๊ฐ์ ์ธ๋ฑ์ค
= ์ฝ์
ํ์ ๋ ์ค๋ฆ์ฐจ์์ด ์ ์ง๋๋ ๊ฐ์ฅ ์ผ์ชฝ ์์น.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int lowerBound(int arr[], int target, int size)
{
int low = 0;
int high = size;
while (low < high)
{
int mid = (low + high) / 2;
if (arr[mid] >= target)
high = mid;
else
low = mid + 1;
}
return low;
}
๊ฐ์ฅ ๋ง์ง๋ง์ ๋์ค๋ ๊ฐ์ ์ธ๋ฑ์ค
= ์ฝ์
ํ์ ๋ ์ค๋ฆ์ฐจ์์ด ์ ์ง๋๋ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์์น.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int upperBound(int arr[], int target, int size)
{
int low = 0;
int high = size;
while (low < high)
{
int mid = (low + high) / 2;
if (arr[mid] > target)
high = mid;
else
low = mid + 1;
}
return low;
}
๐ซ Memo
- C++ STL
binary_search
ํจ์- ๋ฆฌ์คํธ๊ฐ ๋ฐ๋์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ด์ผ ํจ.
- ์์ ์ ๋ฌด๋ฅผ true/false๋ก ๋ฐํ
lower_bound
ํจ์- ์ฐพ๊ณ ์ ํ๋ ๊ฐ ์ด์์ด ์ฒ์ ๋ํ๋๋ ์์น
upper_bound
ํจ์- ์ฐพ๊ณ ์ ํ๋ ๊ฐ ์ด๊ณผ๊ฐ ์ฒ์ ๋ํ๋๋ ์์น
equal_range
ํจ์lower_bound
์upper_bound
๋ฅผ ํ ๋ฒ์ ํธ์ถpair
๋ก ๋ฐํ
- Parametric Search ์ฒ๋ผ STL๊ฐ ๋์์ด ์๋๊ณ ์ง์ ์ด๋ถํ์์ ํด์ผํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค.
- ๋ฌดํ ๋ฃจํ์ ๋น ์ง๋ ๊ฒฝ์ฐ๊ฐ ์๊ธฐ ๋๋ฌธ์ ์ฃผ์
- ๋ฌดํ ๋ฃจํ์ ๋น ์ง์ง ์์ผ๋ ค๋ฉด
- ์ค๋ฒํ๋ก์ฐ ๋ฐฉ์ง:
int mid = low + (high - low) / 2;
- ๊ท ๋ฑํ๊ฒ ๋๋๊ธฐ:
mid = (high - low + 1) / 2;
- ์ค๋ฒํ๋ก์ฐ ๋ฐฉ์ง:
- TODO: