Python

์‹œ๊ฐ„ ๋ณต์žก๋„์™€ ์ด์ค‘ for๋ฌธ

falt ๐Ÿ’Œ o 2021. 6. 4. 15:32
import time

# 0, 1, ..., 9998, 9999
list_a = range(10000)

# list_a์˜ ๋ˆ„์ ํ•ฉ์„ ๊ตฌํ•œ๋‹ค. ์‹œ๊ฐ„๋ณต์žก๋„๋Š” Θ(n²)
def func0(list_a):
    ret = []
    for i in range(len(list_a)):
        suma = 0
        for a in list_a[:i+1]:
            suma += a
        ret.append(suma)
    return ret

# list_a์˜ ๋ˆ„์ ํ•ฉ์„ ๊ตฌํ•œ๋‹ค. ์‹œ๊ฐ„๋ณต์žก๋„๋Š” Θ(n)
def func1(list_a):
    ret = []
    suma = 0
    for a in list_a:
        suma += a
        ret.append(suma)
    return ret

start0 = time.monotonic()
ret0 = func0(list_a)
elapsedtime0 = time.monotonic() - start0

start1 = time.monotonic()
ret1 = func1(list_a)
elapsedtime1 = time.monotonic() - start1

# ๋‘ ํ•จ์ˆซ๊ฐ’์ด ๊ฐ™๋‹ค๋ฉด
if ret0 == ret1:
    print(elapsedtime0, elapsedtime1)

์œ„ ์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•ด๋ณด๋ฉด func0์˜ ์‹คํ–‰ ์‹œ๊ฐ„์€ 2.1089999999999236์ดˆ, func1์˜ ์‹คํ–‰ ์‹œ๊ฐ„์€ 0.016000000000076398์ดˆ์ž„์„ ์•Œ ์ˆ˜ ์žˆ๋‹ค.

๋‘ ํ•จ์ˆ˜์˜ ๋ฐ˜ํ™˜๊ฐ’์€ ๊ฐ™์ง€๋งŒ ์‹คํ–‰ ์‹œ๊ฐ„์€ ๋‹ค๋ฅด๋‹ค. ์™œ ๊ทธ๋Ÿด๊นŒ?

list_a์˜ ๊ธธ์ด๋ฅผ n์ด๋ผ ํ•˜์ž. ์œ„ ์ฝ”๋“œ์—์„œ๋Š” n=10000์ด๋‹ค.

func0์„ ๋ณด๋ฉด ์ด์ค‘ for๋ฌธ์ด ์‚ฌ์šฉ๋˜์—ˆ๋‹ค. ๋ฐ”๊นฅ for๋ฌธ์€ list_a์˜ ๊ธธ์ด, ์ฆ‰ n๋ฒˆ ๋ฐ˜๋ณต๋˜๊ณ , ์•ˆ์ชฝ for๋ฌธ์€ i๋ฒˆ ๋ฐ˜๋ณต๋˜๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ๋‹ค. ๋ฐ”๊นฅ for๋ฌธ์ด ํ•œ ๋ฒˆ ๋Œ ๋•Œ๋งˆ๋‹ค i๋Š” 1์”ฉ ์ฆ๊ฐ€ํ•œ๋‹ค. ์—ฌ๊ธฐ์„œ i๋Š” ์ฒซ์งธํ•ญ์ด 0, ๋งˆ์ง€๋ง‰ํ•ญ์ด n-1, ๊ณต์ฐจ๊ฐ€ 1์ธ ๋“ฑ์ฐจ์ˆ˜์—ด์˜ ์›์†Œ์ด๋‹ค. ๋”ฐ๋ผ์„œ ์•ˆ์ชฝ for๋ฌธ์ด ๋ฐ˜๋ณต๋˜๋Š” ํšŸ์ˆ˜๋Š” ๋“ฑ์ฐจ์ˆ˜์—ด์˜ ํ•ฉ ๊ณต์‹์— ์˜ํ•ด n(n-1)/2์ด๋‹ค. ์—ฐ์‚ฐ ํšŸ์ˆ˜๊ฐ€ n์— ๋Œ€ํ•œ ์ด์ฐจ์‹์œผ๋กœ ๋‚˜ํƒ€๋‚ด์–ด์ง„๋‹ค. ์‹œ๊ฐ„ ๋ณต์žก๋„๋Š” ์—ฐ์‚ฐ ํšŸ์ˆ˜์— ๋น„๋ก€ํ•˜๋ฏ€๋กœ ์‹œ๊ฐ„ ๋ณต์žก๋„๋ฅผ Θ(n(n-1)/2) = Θ(n²) ์ด๋ผ๊ณ  ํ•  ์ˆ˜ ์žˆ๋‹ค.

func1์„ ๋ณด๋ฉด for๋ฌธ์ด ํ•˜๋‚˜์ด๋‹ค. ๋ฐ˜๋ณต๋ฌธ์ด n๋ฒˆ๋งŒํผ ๋ฐ˜๋ณต๋˜๋ฏ€๋กœ ์‹œ๊ฐ„ ๋ณต์žก๋„๋Š” Θ(n)์ด๋‹ค.

์ด๋ฏธ์ง€ ์ถœ์ฒ˜: Comparison computational complexity - Time complexity - Wikipedia  

 

Time complexity - Wikipedia

From Wikipedia, the free encyclopedia Estimate of time taken for running an algorithm Graphs of functions commonly used in the analysis of algorithms, showing the number of operations N as the result of input size n for each function In theoretical compute

en.wikipedia.org

N=n๊ณผ N=n²์˜ ์ฐจ์ด๋Š” ์–ด๋งˆ์–ด๋งˆํ•˜๋‹ค.

n = 100
a = 0

for x in range(10):
    for y in range(n):
        for z in range(n-10):
            a += 1

์œ„ ์ฝ”๋“œ๋Š” ์‚ผ์ค‘ for๋ฌธ์ด์ง€๋งŒ ์‹œ๊ฐ„ ๋ณต์žก๋„๋Š” ์—ฌ์ „ํžˆ Θ(n²)์ด๋‹ค.
์™œ๋ƒํ•˜๋ฉด ๋ช…๋ น ํšŸ์ˆ˜๊ฐ€ (n-10)*n*10 ์œผ๋กœ n์— ๋Œ€ํ•œ ์ด์ฐจ์‹์œผ๋กœ ๋‚˜ํƒ€๋‚ด์–ด์ง€๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.