์ด์ง„ ํƒ์ƒ‰(Binary Search)

2024. 4. 14. 16:36ยท ๐Ÿ‘ฉโ€๐Ÿ’ป ํ”„๋กœ๊ทธ๋ž˜๋ฐ/๐ŸŽ ์•Œ๊ณ ๋ฆฌ์ฆ˜

๐ŸŸฉ ์ •๋ ฌ๋œ ๋ฆฌ์ŠคํŠธ ํ˜•ํƒœ๋กœ ์ฃผ์–ด์ง„ ์›์†Œ๋“ค์„ ์ ˆ๋ฐ˜์”ฉ ์ค„์—ฌ ๊ฐ€๋ฉด์„œ ์›ํ•˜๋Š” ๊ฐ’์„ ๊ฐ€์ง„ ์›์†Œ๋ฅผ ์ฐพ๋Š” ๋ฐฉ๋ฒ•

๋ถ„ํ• ์ •๋ณต ๋ฐฉ๋ฒ•์ด ์ ์šฉ๋จ

์ฃผ์–ด์ง„ ๋ฐฐ์—ด์ด ์ •๋ ฌ๋˜์–ด ์žˆ์ง€ ์•Š์œผ๋ฉด ์ •๋ ฌ ์ˆ˜ํ–‰

 

๐ŸŸฉ ํƒ์ƒ‰ ๋ฐฉ๋ฒ•

๋ฐฐ์—ด์˜ ๊ฐ€์šด๋ฐ ์›์†Œ 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
'๐Ÿ‘ฉโ€๐Ÿ’ป ํ”„๋กœ๊ทธ๋ž˜๋ฐ/๐ŸŽ ์•Œ๊ณ ๋ฆฌ์ฆ˜' ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋‹ค๋ฅธ ๊ธ€
  • 2-3-4 ํŠธ๋ฆฌ
  • ์ด์ง„ ํƒ์ƒ‰ ํŠธ๋ฆฌ(Binary Search Tree)
  • ์ˆœ์ฐจ ํƒ์ƒ‰(Sequential Search)
  • ๋ฒ„ํ‚ท ์ •๋ ฌ(Bucket Sort)
peewoong
peewoong
peewoong
peewoong.log
peewoong
์ „์ฒด
์˜ค๋Š˜
์–ด์ œ
  • ๋ถ„๋ฅ˜ ์ „์ฒด๋ณด๊ธฐ
    • ๐Ÿ™‚ Info
    • ๐ŸŽฎ ๊ฒŒ์ž„ ๊ด€๋ จ ๊ฐœ๋…
    • ๐Ÿ‘ฉโ€๐Ÿ’ป ํ”„๋กœ๊ทธ๋ž˜๋ฐ
      • ๐ŸŽญ C
      • ๐ŸŽ  C++
      • ๐Ÿ• C#
      • โœจ ์ž๋ฃŒ๊ตฌ์กฐ
      • ๐ŸŽ ์•Œ๊ณ ๋ฆฌ์ฆ˜
      • ๐Ÿ”ข ์ˆ˜ํ•™
      • ๐ŸŽจ ๊ทธ๋ž˜ํ”ฝ์Šค
    • โš™๏ธ ์—”์ง„
      • ๐Ÿง€ VS
      • ๐Ÿค ์œ ๋‹ˆํ‹ฐ
      • ๐Ÿซ ์–ธ๋ฆฌ์–ผ
      • ๐Ÿน DirectX
      • ๐Ÿฆฅ error
    • ๐Ÿ“ฝ๏ธ ํ”„๋กœ์ ํŠธ
    • ๐Ÿง ์ฝ”๋”ฉํ…Œ์ŠคํŠธ

๋ธ”๋กœ๊ทธ ๋ฉ”๋‰ด

  • ํ™ˆ
  • ํƒœ๊ทธ
  • ๋ฐฉ๋ช…๋ก

๊ณต์ง€์‚ฌํ•ญ

์ธ๊ธฐ ๊ธ€

ํƒœ๊ทธ

์ตœ๊ทผ ๋Œ“๊ธ€

์ตœ๊ทผ ๊ธ€

hELLO ยท Designed By ์ •์ƒ์šฐ.v4.2.0
peewoong
์ด์ง„ ํƒ์ƒ‰(Binary Search)
์ƒ๋‹จ์œผ๋กœ

ํ‹ฐ์Šคํ† ๋ฆฌํˆด๋ฐ”

๋‹จ์ถ•ํ‚ค

๋‚ด ๋ธ”๋กœ๊ทธ

๋‚ด ๋ธ”๋กœ๊ทธ - ๊ด€๋ฆฌ์ž ํ™ˆ ์ „ํ™˜
Q
Q
์ƒˆ ๊ธ€ ์“ฐ๊ธฐ
W
W

๋ธ”๋กœ๊ทธ ๊ฒŒ์‹œ๊ธ€

๊ธ€ ์ˆ˜์ • (๊ถŒํ•œ ์žˆ๋Š” ๊ฒฝ์šฐ)
E
E
๋Œ“๊ธ€ ์˜์—ญ์œผ๋กœ ์ด๋™
C
C

๋ชจ๋“  ์˜์—ญ

์ด ํŽ˜์ด์ง€์˜ URL ๋ณต์‚ฌ
S
S
๋งจ ์œ„๋กœ ์ด๋™
T
T
ํ‹ฐ์Šคํ† ๋ฆฌ ํ™ˆ ์ด๋™
H
H
๋‹จ์ถ•ํ‚ค ์•ˆ๋‚ด
Shift + /
โ‡ง + /

* ๋‹จ์ถ•ํ‚ค๋Š” ํ•œ๊ธ€/์˜๋ฌธ ๋Œ€์†Œ๋ฌธ์ž๋กœ ์ด์šฉ ๊ฐ€๋Šฅํ•˜๋ฉฐ, ํ‹ฐ์Šคํ† ๋ฆฌ ๊ธฐ๋ณธ ๋„๋ฉ”์ธ์—์„œ๋งŒ ๋™์ž‘ํ•ฉ๋‹ˆ๋‹ค.