๐Ÿ“šย ์ˆœ์ฐจ ํƒ์ƒ‰(Sequential Search) ์•Œ๊ณ ๋ฆฌ์ฆ˜

์ˆœ์ฐจ ํƒ์ƒ‰ (Sequential Search) ์ด๋ž€ ๋ฆฌ์ŠคํŠธ ์•ˆ์— ์žˆ๋Š” ํŠน์ •ํ•œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฐพ๊ธฐ ์œ„ํ•ด ์•ž์—์„œ๋ถ€ํ„ฐ ๋ฐ์ดํ„ฐ๋ฅผ ํ•˜๋‚˜์”ฉ ํ™•์ธํ•˜๋Š” ๋ฐฉ๋ฒ•.

  • ๋ณดํ†ต ์ •๋ ฌ๋˜์ง€ ์•Š์€ ๋ฆฌ์ŠคํŠธ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฐพ์„ ๋•Œ ์‚ฌ์šฉ.
  • ๋ฆฌ์ŠคํŠธ ๋‚ด์— ๋ฐ์ดํ„ฐ๊ฐ€ ์•„๋ฌด๋ฆฌ ๋งŽ์•„๋„ ์‹œ๊ฐ„๋งŒ ์žˆ๋‹ค๋ฉด ์›ํ•˜๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์ฐพ์„ ์ˆ˜ ์žˆ๋‹ค๋Š” ์žฅ์ .
  • ๋ฐ์ดํ„ฐ ๊ฐœ์ˆ˜๊ฐ€ N๊ฐœ์ผ ๋•Œ ์ตœ๋Œ€ N๋ฒˆ์˜ ๋น„๊ต ์—ฐ์‚ฐ์ด ํ•„์š”ํ•˜๋ฏ€๋กœ ์ตœ์•…์˜ ๊ฒฝ์šฐ ์‹œ๊ฐ„๋ณต์žก๋„ O(N)
def sequential_search(n, target, array):
    for i in range(n):
        if array[i] == target:
            return i + 1

input_data = input().split()
n = int(input_data[0])
target = input_data[1]

array = input().split()

print(sequential_search(n, target, array))

๐Ÿ“šย ์ด์ง„ ํƒ์ƒ‰(Binary Search) ์•Œ๊ณ ๋ฆฌ์ฆ˜

์ด์ง„ ํƒ์ƒ‰ (Binary Search) ์ด๋ž€ ์ •๋ ฌ๋˜์–ด ์žˆ๋Š” ๋ฆฌ์ŠคํŠธ์—์„œ ํƒ์ƒ‰ ๋ฒ”์œ„๋ฅผ ์ ˆ๋ฐ˜์”ฉ ์ขํ˜€๊ฐ€๋ฉฐ ๋ฐ์ดํ„ฐ๋ฅผ ํƒ์ƒ‰ํ•˜๋Š” ๋ฐฉ๋ฒ•.

  • ์ด์ง„ ํƒ์ƒ‰์€ ์‹œ์ž‘์ , ๋์ , ์ค‘๊ฐ„์ ์„ ์ด์šฉํ•˜์—ฌ ํƒ์ƒ‰ ๋ฒ”์œ„๋ฅผ ์„ค์ •.
  • ํ€ต ์ •๋ ฌ(quick_sort)๊ณผ ๋น„์Šทํ•˜๊ฒŒ ํƒ์ƒ‰ ๋ฒ”์œ„๋ฅผ ์ ˆ๋ฐ˜์”ฉ ์ขํ˜€๊ฐ€๋ฉฐ ๋ฐ์ดํ„ฐ๋ฅผ ํƒ์ƒ‰.
  • ๋ฐ์ดํ„ฐ๋ฅผ ํ•œ๋ฒˆ ํ™•์ธํ• ๋•Œ๋งˆ๋‹ค ์›์†Œ์˜ ๊ฐœ์ˆ˜๊ฐ€ ์ ˆ๋ฐ˜์”ฉ ๊ฐ์†Œํ•œ๋‹ค๋Š” ์ ์—์„œ ์‹œ๊ฐ„ ๋ณต์žก๋„๊ฐ€ O(logN)
    • ์ดˆ๊ธฐ ๋ฐ์ดํ„ฐ ๊ฐœ์ˆ˜๊ฐ€ 32๊ฐœ์ผ ๋•Œ, ์ด์ƒ์ ์œผ๋กœ 1๋‹จ๊ณ„๋ฅผ ๊ฑฐ์น˜๋ฉด 16๊ฐœ๊ฐ€๋Ÿ‰์˜ ๋ฐ์ดํ„ฐ๋งŒ ๋‚จ๋Š”๋‹ค.
    • 2๋‹จ๊ณ„๋ฅผ ๊ฑฐ์น˜๋ฉด 8๊ฐœ๊ฐ€๋Ÿ‰์˜ ๋ฐ์ดํ„ฐ๋งŒ ๋‚จ๋Š”๋‹ค.
    • 3๋‹จ๊ณ„๋ฅผ ๊ฑฐ์น˜๋ฉด 4๊ฐœ๊ฐ€๋Ÿ‰์˜ ๋ฐ์ดํ„ฐ๋งŒ ๋‚จ๋Š”๋‹ค.
  • ์ด์ง„ํƒ์ƒ‰์„ ๊ตฌํ˜„ํ•˜๋Š” ๋ฐฉ๋ฒ•์—๋Š” 2๊ฐ€์ง€(์žฌ๊ท€ํ•จ์ˆ˜, ๋ฐ˜๋ณต๋ฌธ)

1) ์žฌ๊ท€ํ•จ์ˆ˜

# ์žฌ๊ท€ํ•จ์ˆ˜ ํ˜ธ์ถœ
'''
10 7
1 3 5 7 9 11 13 15 17 19
'''
def binary_search_recursive(array, target, start, end):
    if start > end:
        return None

    mid = (start + end) // 2
    # ์ฐพ์€ ๊ฒฝ์šฐ ์ค‘๊ฐ„์  ์ธ๋ฑ์Šค ๋ฐ˜ํ™˜
    if array[mid] == target:
        return mid
    # ์ค‘๊ฐ„์ ์˜ ๊ฐ’๋ณด๋‹ค ์ฐพ๊ณ ์ž ํ•˜๋Š” ๊ฐ’์ด ์ž‘์€ ๊ฒฝ์šฐ ์™ผ์ชฝ ํ™•์ธ
    elif array[mid] > target:
        return binary_search_recursive(array, target, start, mid-1)
    # ์ค‘๊ฐ„์ ์˜ ๊ฐ’๋ณด๋‹ค ์ฐพ๊ณ ์ž ํ•˜๋Š” ๊ฐ’์ด ํฐ ๊ฒฝ์šฐ ์˜ค๋ฅธ์ชฝ ํ™•์ธ
    else:
        return binary_search_recursive(array, target, mid+1, end)

# n(์›์†Œ์˜ ๊ฐœ์ˆ˜)๊ณผ target(์ฐพ๊ณ ์ž ํ•˜๋Š” ๋ฌธ์ž์—ด)์„ ์ž…๋ ฅ๋ฐ›๊ธฐ
n, target = list(map(int, input().split()))
# ์ „์ฒด ์›์†Œ ์ž…๋ ฅ๋ฐ›๊ธฐ
array = list(map(int, input().split()))
result = binary_search_recursive(array, target, 0, n-1)

# ์ด์ง„ ํƒ์ƒ‰ ์ˆ˜ํ–‰ ๊ฒฐ๊ณผ ์ถœ๋ ฅ
if result == None:
    print('์ฐพ๋Š” ๊ฐ’์ด ์—†์Šต๋‹ˆ๋‹ค.')
else:
    print(result + 1)

์‹คํ–‰๊ฒฐ๊ณผ

10 7
1 3 5 7 9 11 13 15 17 19
4

10 7
1 3 5 6 9 11 13 15 17 19
์›์†Œ๊ฐ€ ์กด์žฌํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค

2) ๋ฐ˜๋ณต๋ฌธ

# ์ด์ง„ ํƒ์ƒ‰ ์†Œ์Šค์ฝ”๋“œ ๊ตฌํ˜„ (๋ฐ˜๋ณต๋ฌธ)
def binary_search(array, target, start, end):
    while start <= end:
        mid = (start + end) // 2
        # ์ฐพ์€ ๊ฒฝ์šฐ ์ค‘๊ฐ„์  ์ธ๋ฑ์Šค ๋ฐ˜ํ™˜
        if array[mid] == target:
            return mid
        # ์ค‘๊ฐ„์ ์˜ ๊ฐ’๋ณด๋‹ค ์ฐพ๊ณ ์ž ํ•˜๋Š” ๊ฐ’์ด ์ž‘์€ ๊ฒฝ์šฐ ์™ผ์ชฝ ํ™•์ธ
        elif array[mid] > target:
            end = mid - 1
        # ์ค‘๊ฐ„์ ์˜ ๊ฐ’๋ณด๋‹ค ์ฐพ๊ณ ์ž ํ•˜๋Š” ๊ฐ’์ด ํฐ ๊ฒฝ์šฐ ์˜ค๋ฅธ์ชฝ ํ™•์ธ
        else:
            start = mid + 1
    return None

# n(์›์†Œ์˜ ๊ฐœ์ˆ˜)๊ณผ target(์ฐพ๊ณ ์ž ํ•˜๋Š” ๊ฐ’)์„ ์ž…๋ ฅ ๋ฐ›๊ธฐ
n, target = list(map(int, input().split()))
# ์ „์ฒด ์›์†Œ ์ž…๋ ฅ ๋ฐ›๊ธฐ
array = list(map(int, input().split()))

# ์ด์ง„ ํƒ์ƒ‰ ์ˆ˜ํ–‰ ๊ฒฐ๊ณผ ์ถœ๋ ฅ
result = binary_search(array, target, 0, n - 1)
if result == None:
    print("์›์†Œ๊ฐ€ ์กด์žฌํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.")
else:
    print(result + 1)

์‹คํ–‰๊ฒฐ๊ณผ

10 7
1 3 5 7 9 11 13 15 17 19
4

10 7
1 3 5 6 9 11 13 15 17 19
์›์†Œ๊ฐ€ ์กด์žฌํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค

์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ ์—์„œ์˜ ์ด์ง„ ํƒ์ƒ‰

  • ์ด์ง„ ํƒ์ƒ‰์€ ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ์—์„œ ๋‹จ๊ณจ๋กœ ๋‚˜์˜ค๋ฏ€๋กœ ๊ฐ€๊ธ‰์  ์™ธ์šฐ๊ธธ ๊ถŒํ•จ.(์ฐธ๊ณ ํ•  ์†Œ์Šค์ฝ”๋“œ๊ฐ€ ์—†๋Š” ์ƒํƒœ์—์„œ๋Š” ์ด์ง„ ํƒ์ƒ‰์˜ ๊ตฌํ˜„์ด ์ƒ๋‹นํžˆ ์–ด๋ ค์šธ ์ˆ˜ ์žˆ์Œ)
  • ํƒ์ƒ‰ ๋ฒ”์œ„๊ฐ€ 2000๋งŒ์ด ๋„˜์–ด๊ฐ€๋ฉด ์ด์ง„ ํƒ์ƒ‰์œผ๋กœ ๋ฌธ์ œ์— ์ ‘๊ทผํ•˜๊ธธ ๊ถŒํ•จ.
    • 1000๋งŒ ๋‹จ์œ„ ์ด์ƒ์œผ๋กœ ๋„˜์–ด๊ฐ€๋ฉด ์ด์ง„ ํƒ์ƒ‰๊ณผ ๊ฐ™์ดO(logN)์˜ ์†๋„๋ฅผ ๋‚ด์•ผ ํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ๋– ์˜ฌ๋ ค์•ผ ๋ฌธ์ œ๋ฅผ ํ’€ ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๋‹ค.

์ด์ง„ ํƒ์ƒ‰๊ณผ ์ˆœ์ฐจ ํƒ์ƒ‰ ๋น„๊ต

์ด์ง„vs์ˆœ์ฐจ

๐Ÿ“šย ํŠธ๋ฆฌ ์ž๋ฃŒ๊ตฌ์กฐ

  • ๋…ธ๋“œ์™€ ๋…ธ๋“œ์˜ ์—ฐ๊ฒฐ๋กœ ํ‘œํ˜„ํ•˜๋ฉฐ ์—ฌ๊ธฐ์—์„œ ๋…ธ๋“œ๋Š” ์ •๋ณด์˜ ๋‹จ์œ„๋กœ์„œ ์–ด๋– ํ•œ ์ •๋ณด๋ฅผ ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๊ฐœ์ฒด๋กœ ์ดํ•ดํ•  ์ˆ˜ ์žˆ์Œ.
  • ํฐ ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•˜๋Š” ์†Œํ”„ํŠธ์›จ์–ด๋Š” ๋Œ€๋ถ€๋ถ„ ๋ฐ์ดํ„ฐ ํŠธ๋ฆฌ ์ž๋ฃŒ๊ตฌ์กฐ๋กœ ์ €์žฅํ•ด์„œ ์ด์ง„ํƒ์ƒ‰๊ณผ ๊ฐ™์€ ํƒ์ƒ‰ ๊ธฐ๋ฒ•์„ ์ด์šฉํ•ด ๋น ๋ฅด๊ฒŒ ํƒ์ƒ‰์ด ๊ฐ€๋Šฅํ•จ.

ํŠธ๋ฆฌ์˜ ํŠน์ง•

ํŠธ๋ฆฌ

  • ํŠธ๋ฆฌ๋Š” ๋ถ€๋ชจ ๋…ธ๋“œ์™€ ์ž์‹ ๋…ธ๋“œ์˜ ๊ด€๊ณ„๋กœ ํ‘œํ˜„ํ•œ๋‹ค.
  • ํŠธ๋ฆฌ์˜ ์ตœ์ƒ๋‹จ ๋…ธ๋“œ๋ฅผ ๋ฃจํŠธ ๋…ธ๋“œ๋ผ๊ณ  ํ•œ๋‹ค.
  • ํŠธ๋ฆฌ์˜ ์ตœํ•˜๋‹จ ๋…ธ๋“œ๋ฅผ ๋‹จ๋ง ๋…ธ๋“œ๋ผ๊ณ  ํ•œ๋‹ค.
  • ํŠธ๋ฆฌ์—์„œ ์ผ๋ถ€๋ฅผ ๋–ผ์–ด๋‚ด๋„ ํŠธ๋ฆฌ ๊ตฌ์กฐ์ด๋ฉฐ ์ด๋ฅผ ์„œ๋ธŒ ํŠธ๋ฆฌ๋ผ๊ณ  ํ•œ๋‹ค.
  • ํŠธ๋ฆฌ๋Š” ํŒŒ์ผ ์‹œ์Šคํ…œ๊ณผ ๊ฐ™์ด ๊ณ„์ธต์ ์ด๊ณ  ์ •๋ ฌ๋œ ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฃจ๊ธฐ์— ์ ํ•ฉํ•˜๋‹ค.

๐Ÿ“šย ์ด์ง„ ํƒ์ƒ‰ ํŠธ๋ฆฌ

  • ํŠธ๋ฆฌ ์ž๋ฃŒ ๊ตฌ์กฐ์ค‘ ๊ฐ€์žฅ ๊ฐ„๋‹จํ•œ ํ˜•ํƒœ.
  • ์ด์ง„ ํƒ์ƒ‰์ด ๋™์ž‘ํ•˜๋„๋ก ๊ณ ์•ˆ๋œ ํ˜•ํƒœ.

์ด์ง„ ํƒ์ƒ‰ ํŠธ๋ฆฌ์˜ ํŠน์ง•

์ด์ง„ํŠธ๋ฆฌ

  • ๋ถ€๋ชจ ๋…ธ๋“œ๋ณด๋‹ค ์™ผ์ชฝ ์ž์‹ ๋…ธ๋“œ๊ฐ€ ์ž‘๋‹ค.
  • ๋ถ€๋ชจ ๋…ธ๋“œ๋ณด๋‹ค ์˜ค๋ฅธ์ชฝ ์ž์‹ ๋…ธ๋“œ๊ฐ€ ํฌ๋‹ค.

๋น ๋ฅด๊ฒŒ ์ž…๋ ฅ๋ฐ›๊ธฐ

  • Python input() ํ•จ์ˆ˜๋Š” ๋™์ž‘ ์†๋„๊ฐ€ ๋А๋ฆผ.
    • sys ๋ผ์ด์ด๋ธŒ๋Ÿฌ๋ฆฌ readline() ํ•จ์ˆ˜๋ฅผ ์ด์šฉํ•œ๋‹ค.
  • sys ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ํ•œ ์ค„ ์ž…๋ ฅ๋ฐ›๊ณ  ๋‚˜์„œ rstrip() ํ•จ์ˆ˜๋ฅผ ๊ผญ ํ˜ธ์ถœํ•ด์•ผ ํ•จ.
    • readline()์œผ๋กœ ์ž…๋ ฅํ•˜๋ฉด ์ž…๋ ฅ ํ›„ ์—”ํ„ฐ ๊ฐ€ ์ค„๋ฐ”๊ฟˆ ๊ธฐํ˜ธ๋กœ ์ž…๋ ฅ๋˜๋Š”๋ฐ, ๊ณต๋ฐฑ ๋ฌธ์ž๋ฅผ ์ œ๊ฑฐํ•˜๋ ค๋ฉด rstrip()๋ฅผ ์‚ฌ์šฉํ•ด์•ผํ•œ๋‹ค.
import sys
# ํ•˜๋‚˜์˜ ๋ฌธ์ž์—ด ๋ฐ์ดํ„ฐ ์ž…๋ ฅ๋ฐ›๊ธฐ
input()_data = sys.stdin.readline().rstrip()

# ์ž…๋ ฅ๋ฐ›์€ ๋ฌธ์ž์—ด ๊ทธ๋Œ€๋กœ ์ถœ๋ ฅ
print(input_data)

๋Œ“๊ธ€๋‚จ๊ธฐ๊ธฐ