1. ์ด๋ถ ํ์ (binary-search)๋ ๋ฌด์์ธ๊ฐ์?
์ด๋ถ ํ์(binary-search)
์ด๋, ์ ๋ ฌ๋ ์ํ์ ์ผ๋ จ์ ๋ฐ์ดํฐ ์ค ํ ๊ธฐ์ ์์ ๋ต ํ๋ณด๊ฐ ๋ ์ ์๋ ์ ๋ฐ์ ์ญ์ ํด๊ฐ๋ฉฐ ๋ต์ ์ฐพ์๋ด๋ ํ์ ์๊ณ ๋ฆฌ์ฆ ์ด๋ค.
๋ค์๊ณผ ๊ฐ์ด ์ ๋ ฌ๋ 10๊ฐ์ ์ ์๊ฐ ๋ฐฐ์ด ํํ๋ก ์ฃผ์ด์ ธ ์๋ค๊ณ ํ์. ์ฐ๋ฆฌ๋ ์ฌ๊ธฐ์ 23
์ด๋ ์๋ฅผ ์ฐพ๊ณ ์ ํ๋ค.
(1) ๋จผ์ ๋ชฉํ๊ฐ๊ณผ ๋น๊ตํ ๊ธฐ์ค์ ๊ตฌํด์ผ ํ๋ค. ๊ธฐ์ค์ ํญ์ ๊ฐ์ ๊ตฌํด์ผ ํ๋ ๊ตฌ๊ฐ์ ์ค์๊ฐ์ด๋ค. (์ง์๋ฉด์ ์ค์์ ๋ ๊ฐ์ ๊ฐ ์ค ์ ์ชฝ ๊ฐ์ด๋ค.)
(2) 16์ 23๊ณผ ๋น๊ตํด๋ณด๋, ์๋ค. ์ด ๋ง์ ์ฆ '16์ ์์ชฝ ์์๋ค๋ ๋ชฉํ ๊ฐ๋ณด๋ค ์๋ค.' ๋ ๋ง์ด ๋๋ค. ์๋ํ๋ฉด ์ด๋ฏธ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ์ํ์์ ํ์์ ์์ํ๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์ 16๊ณผ ๊ทธ ์ ์ชฝ์ ์๋ค์ ์ ๋ถ ๋ ๋ฆฐ๋ค.
(3) ์ด์ ๋จ์ ์์ญ์์ ๋ค์ ํ์ํ๋ค. ํ์ ๊ณผ์ ์ (1)์์ (2)๋ฅผ ๋ฐ๋ณตํ๋ฉด ๋๋ค. ์ฌ๊ธฐ์ ์ค์๊ฐ์56์ด๊ณ 23๊ณผ ๋น๊ต ํ๋ ํฌ๋ค. ๋ฐ๋ผ์ 56๊ณผ ๊ทธ ์ด์์ ๊ฐ๋ค์ ์ญ์ ํ๋ค. ๋ณด์ง ์์๋ ๊ฑฐ๊ธฐ์ ๋ต์ด ์๋ค๋ ๊ฒ์ ์๋ค.
(4) 23๊ณผ 38์ ์ค์๊ฐ์ ๊ตฌํ๋, ์ ์ชฝ์ ์๋ 23์ด ๋์๋ค. 23์ ์ฐ๋ฆฌ๊ฐ ๊ตฌํ๋ ค๋ ๋ชฉํ๊ฐ๊ณผ ๊ฐ๋ค. ๊ฐ์ ์ฐพ์์์ผ๋ก, ์ด๋ถ ํ์์ ์ข ๋ฃํ๋ค.
2. ์ด๋ป๊ฒ ๊ตฌํ ํ๋์?
(1) ๋ก์ง
(2) ๊ตฌํ
a. SUDO CODE
// ๋ฐฐ์ด ๋ด์์ ํ๊ฒ ๊ฐ์ ์์น ์ฐพ๊ธฐ!
์ด๋ถํ์(start, end, target)
while(start <= end){
// ์ค์ ๊ฐ ๊ตฌํ๊ธฐ
mid = start ์ end์ ์ค๊ฐ index;
if(mid๊ฐ ๊ฐ๋ฅดํค๋ ๊ฐ์ด ๋ชฉํ๊ฐ ๋ณด๋ค ์๋ค.) ์ค๊ฐ๊ฐ ์ํฅ ์กฐ์ ํ์. start = mid + 1 ๋ก ์ฌ์กฐ์ ;
else ์ค๊ฐ๊ฐ ํํฅ ์กฐ์ ํ์. end = mid - 1 ๋ก ์ฌ์กฐ์ ;
}
if(start๊ฐ ๊ฐ๋ฅดํค๋ ๊ฐ == target) return start;
else return null;
b. ์ฝ๋ Java
import java.io.*;
import java.util.ArrayDeque;
public class Main {
public static void main(String[] args) throws IOException {
int [] arr = new int []{10,15,38,39,45,72,89,95,100,102};
System.out.println(binary_search(arr, 0, arr.length-1, 72));
}
public static int binary_search(int [] arr, int start, int end, int target){
while(start <= end){
int mid = start + (end - start)/2;
if(arr[mid] < target) start = mid+1;
else end = mid-1;
}
if(arr[start] == target) return start;
else return -1;
}
}
์ ์ฝ๋๋ target ๊ฐ์ index๋ฅผ ์ฐพ๋ ์ฝ๋์ด๋ค.
3. ์ด๋ถํ์์ ์์ฉ
์ต์ ํ ๋ฌธ์
๋ฅผ ํ ๋, ์ด๋ถ ํ์์ ์์ฉ ํด์ผ ํ๋ค.
์ต์ ํ ๋ฌธ์
๋?
๋ฌธ์ ์์ 'A๋ฅผ ๊ตฌํ๋ผ', 'A๊ฐ ์๋์ง ์๋์ง๋ฅผ ๊ตฌํ๋ผ'์ ๊ฐ์ด, ๋ฐํํด์ผํ ๊ฐ์ด ํ๋์ ๊ฐ์ผ๋ก ๋ช
ํํ ๋ฌธ์ ๋ฅผ ๊ฒฐ์ ๋ฌธ์
๋ผ ํ๋ค. ์ด์ ๋ค๋ฅด๊ฒ '๋ต์ด ๋ ์ ์๋ ๊ฐ ์ค ์ต์๊ฐ ํน์ ์ต๋๊ฐ์ ๊ตฌํ๋ผ'์ ๊ฐ์ด, ๋ต์ด ๋ ์ ์๋ ๋ณต์์ ๊ฐ์ด ์กด์ฌํ๊ณ ๊ทธ ์ค ๋ฌธ์ ์์ ๋ฐ๋ผ๋ ์ต์ ์ ๋ต์ ๊ตฌํ๋ ๊ฒ์ ์ต์ ํ ๋ฌธ์
๋ผ๊ณ ํ๋ค.
๊ธฐ๋ณธ์ ์ธ ์ด๋ถํ์ ๋ฌธ์ ๋ ๊ตฌํ๊ธธ ๋ฐ๋ผ๋ target๊ฐ์ด ๋ฒ์ฃผ ๋ด์ ์๋์ง ์ฌ๋ถ ํน์, ๋ช ๋ฒ์ธ์ง๋ฅผ ๊ตฌํ๋ ๊ฒฐ์ ๋ฌธ์ ์๋ค. ๋ฐ๋ฉด ์กฐ๊ฑด์ ์ถฉ์กฑํ๋ ์ ์ค ์ต์๊ฐ์ ๊ตฌํ๊ธธ ๋ฐ๋ผ๋ ์ต์ ํ ๋ฌธ์ ๋ ๋์ฌ ์ ์๋ค.
์ด์ ์ ๋ต์ ์ถฉ์กฑํ๋ ๊ฐ์ ๋ง๋๋ฉด ๋ฐ๋ก ํ์ถํด๋ ๋์์ง๋ง...
์ด์ ๋ ๊ทธ๋ด ์ ์๋ค. ๋ฐ๋ผ์ mid๋ผ๋ ํฌ์ธํฐ๋ฅผ ๋ฒ์ฃผ ๋์ ๋ค๋ค๋ฅด๊ฒ ํด์ค ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์ฌ์ฉํด์ผ ํ๋ค. ์ด๋ฌํ ๋ฐฉ๋ฒ์๋ LOWER BOUND
์ UPPER BOUND
๊ฐ ์๋ค.
(1) LOWER BOUND
mid ํฌ์ธํฐ๊ฐ ๊ฐ๋ฅดํค๋ ๊ฐ์ด target๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด ํํฅ์กฐ์ ํ๋ ๋ฐฉ์์ด๋ค. ์ด๋ ๊ฐ์๋ ํํฅ์กฐ์ ํด๋ฒ๋ฆผ์ผ๋ก, mid ํฌ์ธํฐ๋ ๋ต์ด ๋ ์ ์๋ ๊ฐ ์ค ์ต์๊ฐ์ ์ข ๊ตญ์ ๋ค๋ค๋ฅด๊ฒ ๋๋ค.
- (1)
arr[mid]
>=target
: end = mid -1; - (2)
arr[mid]
<target
: start = mid + 1;
(2) UPPER BOUND
Lower Bound์ ๋ฐ๋๋ก, mid ํฌ์ธํฐ๊ฐ ๊ฐ๋ฅดํค๋ ๊ฐ์ด target๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ผ๋ฉด ์ํฅ์กฐ์ ํ๋ค. ์ด๋ ๊ฒ ํ๋ฉด mid ํฌ์ธํฐ๋ ๊ฒฐ๊ตญ Target ๊ฐ๋ณด๋ค ํฐ ๊ฐ์ ์์์ ์ ๊ฐ๋ฅดํค๊ฒ ๋๋ค. (์ฆ ๋ต์ด ๋ ์ ์๋ ์ต๋๊ฐ์ index + 1์นธ์ ๊ฐ๋ฆฌํด.)
- (1)
arr[mid]
<=target
: start = mid + 1; - (2)
arr[mid]
>target
: end = mid - 1;