๐ฉ ์ ๋ ฌ๋ ๋ฆฌ์คํธ ํํ๋ก ์ฃผ์ด์ง ์์๋ค์ ์ ๋ฐ์ฉ ์ค์ฌ ๊ฐ๋ฉด์ ์ํ๋ ๊ฐ์ ๊ฐ์ง ์์๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ
๋ถํ ์ ๋ณต ๋ฐฉ๋ฒ์ด ์ ์ฉ๋จ
์ฃผ์ด์ง ๋ฐฐ์ด์ด ์ ๋ ฌ๋์ด ์์ง ์์ผ๋ฉด ์ ๋ ฌ ์ํ
๐ฉ ํ์ ๋ฐฉ๋ฒ
๋ฐฐ์ด์ ๊ฐ์ด๋ฐ ์์ A[mid]์ ํ์ํค key๋ฅผ ๋น๊ต
๐ ์ค๊ฐ ๊ฐ์ ๊ตฌํ๋ ๋ฐฉ์
1. mid : low + (high-low) / 2
2. mid : (low + high) / 2 ๐ low + high ๊ฐ์ด (2^31-1)์ ๋ฒ์๋ณด๋ค ํฌ๋ค๋ฉด ์์๊ฐ์ผ๋ก ์ค๋ฒํ๋ก์ฐ ๋ฐ์ ๊ฐ๋ฅ
1. A[mid] = key ๐ ํ์ ์ฑ๊ณต (์ธ๋ฑ์ค mid ๋ฐํ ํ ์ข ๋ฃ)
2. A[mid] < key ๐ ์ด์ง ํ์(์๋ ํฌ๊ธฐ์ 1/2์ธ ์ค๋ฅธ์ชฝ ๋ถ๋ถ๋ฐฐ์ด) ์ํ ํธ์ถ
3. A[mid] > key ๐ ์ด์ง ํ์(์๋ ํฌ๊ธฐ์ 1/2์ธ ์ผ์ชฝ ๋ถ๋ถ๋ฐฐ์ด) ์ํ ํธ์ถ
๐ ํ์์ ๋ฐ๋ณตํ ๋๋ง๋ค ๋์ ์์์ ๊ฐ์๊ฐ 1/2์ฉ ๊ฐ์
๐ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํ๋ ๋ฐฉ๋ฒ
int BSearch(int arr[], int target) {
int low = 0;
int high = arr.length - 1;
int mid;
while(low <= high) {
mid = (low + high) / 2;
if (arr[mid] == target)
return mid;
else if (arr[mid] > target)
high = mid - 1;
else
low = mid + 1;
}
return -1;
}
๐ ์ฌ๊ทํจ์๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ
int BSearchRecursive(int arr[], int target, int low, int high) {
if (low > high)
return -1;
int mid = (low + high) / 2;
if (arr[mid] == target)
return mid;
else if (arr[mid] > target)
return BSearchRecursive(arr, target, low, mid-1);
else
return BSearchRecursive(arr, target, mid+1, high);
}
๐ฉ ์๊ฐ ๋ณต์ก๋ O(logn)
ํ์ : O(logn)
์ด๊ธฐํ : O(nlogn)
์ฝ์ /์ญ์ : O(n)
๐ฉ ํ์ฉ
์ฝ์ ๊ณผ ์ญ์ ๊ฐ ๋น๋ฒํ ๊ฒฝ์ฐ์๋ ๋ถ์ ํฉ
์ฐ์ฐ ํ ๋ฆฌ์คํธ์ ์ ๋ ฌ ์ํ๋ฅผ ์ ์งํ๊ธฐ ์ํด์๋ O(n)์ ๋ฐ์ดํฐ ์ด๋ ํ์ ๐ ๋ฐ์ดํฐ๊ฐ ์์ ๊ฒฝ์ฐ ์ ํฉ
'๐ฉโ๐ป ํ๋ก๊ทธ๋๋ฐ > ๐ ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
2-3-4 ํธ๋ฆฌ (0) | 2024.04.14 |
---|---|
์ด์ง ํ์ ํธ๋ฆฌ(Binary Search Tree) (0) | 2024.04.14 |
์์ฐจ ํ์(Sequential Search) (0) | 2024.04.14 |
๋ฒํท ์ ๋ ฌ(Bucket Sort) (0) | 2024.04.13 |
๊ธฐ์ ์ ๋ ฌ(Radix Sort) (0) | 2024.04.13 |