๐ฉ๐ป ์ด์ง ํ์ (Binary Search) ๋?
์ด์ง ํ์์ (= ์ด๋ถ ํ์) ์ ๋ ฌ๋ ์ํ์ ๋ฐ์ดํฐ์์ ํน์ ๊ฐ์ ๋น ๋ฅด๊ฒ ํ์ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
- ์ฐพ๊ณ ์ ํ๋ ๊ฐ๊ณผ ๋ฐ์ดํฐ ์ค์์ ์๋ ๊ฐ์ ๋น๊ต
- ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ๋ ์์ผ๋ฉด ๋ฐ์ดํฐ ์ผ์ชฝ ๋ถ๋ถ์์ ์ด์ง ํ์
- ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ๋ ํฌ๋ฉด ๋ฐ์ดํฐ ์ค๋ฅธ์ชฝ ๋ถ๋ถ์์ ์ด์ง ํ์
โ๏ธ ์๊ฐ ๋ณต์ก๋
์๊ณ ๋ฆฌ์ฆ ์๊ฐ ๋ณต์ก๋ : O(logN)
โ๏ธ ์ด์ง ํ์ ๊ณผ์
* ๋ฐ์ดํฐ๊ฐ ์ฐ์ ์ ๋ ฌ๋ ์ํ์ฌ์ผ ์ด์ง ํ์ ์งํ์ด ๊ฐ๋ฅํ๋ค.
์ฐพ๊ณ ์ ํ๋ ๋ฐ์ดํฐ x๋ฅผ ๊ธฐ์ค์ผ๋ก mid ๊ฐ๊ณผ ๋น๊ตํ์ฌ ๋ฒ์๋ฅผ ์ค์ฌ๋๊ฐ๋ฉฐ ์ฐพ์๊ฐ๋ ๋ฐฉ์์ด๋ค.
โ๏ธ ์ด์ง ํ์ ๊ตฌํ ๊ณผ์
โจ ๋ฐ๋ณต๋ฌธ ๊ตฌ์กฐ
public class Main{
public static int binarySearch(int arr[], int target){
int left = 0;
int right = arr.length - 1;
while(left <= right){
int mid = (left + right) / 2;
if(target == arr[mid]){
return mid;
}else if(target < arr[mid]{
right = mid - 1;
}else{
left = mid + 1;
}
}
return -1;
}
}
โจ ์ฌ๊ท ํธ์ถ ๊ตฌ์กฐ
public class Main{
public static int binarySearch2(int[] arr, int target, int left, int right){
if(left > right){
return -1;
}
int mid = (left + right) / 2;
if(target == arr[mid]){
return mid;
}else if(target < arr[mid]){
return binarySearch2(arr, target, left, mid-1);
}else{
return binarySearch2(arr, target, mid+1, right);
}
}
}
โ๏ธ Java์์ ๊ธฐ๋ณธ ์ ๊ณต ๋๋ Binary Search
Arrays.binarySearch(arr, 1); // ๋ฐฐ์ด arr์์ 1์ ์ฐพ๋ ๊ฒฝ์ฐ
Arrays.binarySearch(arr, 10); // ๋ฐฐ์ด arr์์ 10์ ์ฐพ๋ ๊ฒฝ์ฐ
๋ง์ฝ, ๋ฐฐ์ด์์ binarySearch๋ฅผ ์ฌ์ฉํ์๋ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ์๋ค๋ฉด
์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ์์๋ค๋ฉด ์์ด์ผ ํ ์์น์ index * (-1) ๊ฐ์ด ๋ฐํ๋๋ค.
์ฆ, ๊ทธ ๊ฐ์ด ์์์ด์ผ ํ ์๋ฆฌ์ ์ธ๋ฑ์ค ๊ฐ์ ๋ง์ด๋์ค๊ฐ ๋ถ์ ๊ฐ์ด ๋ฐํ๋๋ค.
(ex)
if arr = {1,2,3,5,6,7}, search value = 4
then, Arrays.binarySearch(arr,4) running -3 (4๊ฐ ์กด์ฌํ๋ค๋ฉด index 3๋ฒ ์์น์ ์์์ด์ผ ํ๋ฏ๋ก)
'์๊ณ ๋ฆฌ์ฆ > ์๊ณ ๋ฆฌ์ฆ ์ด๋ก ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ (Divide and Conquer) (0) | 2024.08.02 |
---|---|
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ (Greedy Algorithm) (4) | 2024.07.20 |
ํฌ ํฌ์ธํฐ - ์๊ณ ๋ฆฌ์ฆ (2) | 2024.07.20 |
์ ๋ ฌ (Sort) - ์๊ณ ๋ฆฌ์ฆ (0) | 2024.06.25 |
Knapsack problem - Dynamic Program (0) | 2023.05.20 |