ํด์๋ผ๋ ๋จ์ด๋ ์ํธํ ๊ด๋ จ ์ ๋ณด๋ฅผ ์์๋ณผ ๋ ์ฃผ๋ก ๋ค์๋ ๋จ์ด ๊ฐ๋ค.์ค๋์ ํด์์ ๊ด๋ จํ ๊ฐ๋
์ ๋ํด ์ด ์ ๋ฆฌ๋ฅผ ํด๋ด์ผ๊ฒ ๋ค.Java์์๋ HashTable ๊ณผ HashMap ๋๋ค ์๋๋ฐ, ์ด ํฌ์คํ
์์๋ ๋์ ๊ตฌ๋ถ ์ง์ง๋ ์๊ณ , HashMap ๊ธฐ๋ฐ์ผ๋ก ํ ์ค๋ช
์์ ์๋ ค๋๋ฆฌ๋ ๋ฐ์ด๋ค. ๐ ํด์ ํ
์ด๋ธ ์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ?ํด์(Hash) ๋จ์ด ์์ฒด๋ ์ด๋ค ๊ฐ์ ์ผ์ ๊ธธ์ด๋ก ๋ณํํ๋ ๊ธฐ๋ฒ์ด๊ณ , ํด์ ํ
์ด๋ธ์ ๊ทธ ํด์ ๊ธฐ๋ฒ์ ์ ์ฉํ ์๋ฃ๊ตฌ์กฐ๋ผ๊ณ ํ ์ ์๋ค.๊ฐ๋จํ๊ฒ key-value ๊ตฌ์กฐ๋ก ๋น ๋ฅด๊ฒ ๊ฒ์์ ํ ์ ์๋ค๋ ๊ฒ์ด ํน์ง์ด๋ค๋์ฒด ํด์ ํ
์ด๋ธ์ด ๋ญ๊ธธ๋ ๋น ๋ฅด๊ฒ ๊ฒ์์ ํ ์ ์๋ ๊ฑธ๊น?์ ์ฐ๋ฆฌ๊ฐ ์น๊ตฌ์ ์ ํ๋ฒํธ๋ฅผ ๊ฒ์ํ ์ ์๋ ์ฌ์ดํธ๋ฅผ ๋ง๋ค์๋ค๊ณ ์น์.๊ฒ์์ฐฝ์ ์น๊ตฌ์ ์ด๋ฆ์ ์น๋ฉด ์ ํ๋ฒํธ๊ฐ ๋์ฌ ๊ฒ์ด๋ค..
๐ป Computer Science/์๋ฃ๊ตฌ์กฐ & ์๊ณ ๋ฆฌ์ฆ
๐ ์๋ฃ ๊ตฌ์กฐ๋ ์ ๊ณต๋ถํด์ผํ๋ 1. ์๋ฃ ๊ตฌ์กฐ๊ฐ ๋ฌด์์ธ๊ฐ์๋ฃ ๊ตฌ์กฐ = Data + Structure = ์๋ฃ๋ค์ ์งํฉ์ฆ, ์๋ฃ๊ฐ ๋ญ์ณ์๋ ์๊น์๋ฅผ ๋งํ๋ค.์๋ฃ ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ๋ค์ ๊ด๊ณ๊ฐ ๋
ผ๋ฆฌ์ ์ผ๋ก ์ ์๋ ์ผ์ ํ ๊ท์น์ ์ํด ๋์ด๋๋ค.์๋ฃ์ ๋ํ ์ฒ๋ฆฌ๋ฅผ ํจ์จ์ ์ผ๋ก ์ํํ ์ ์๋๋ก ์๋ฃ๋ฅผ ์กฐ์ง์ , ์ฒด๊ณ์ ์ผ๋ก ๊ตฌ๋ถํด์ ํํํ๊ฑฐ๋ค.์ด๋ฐ ์์ผ๋ก ๋ฑ๋ฑ ๊ตฌ๋ถ์ง์ด์ ์์๊ฒ ๋์ ๊ฑฐ๋ ๋ง์ด๋ค. 2. ์๋ฃ ๊ตฌ์กฐ์ ๋ชฉ์ ์๋ฃ๊ตฌ์กฐ์ ๋ชฉ์ ์ ํฌ๊ฒ 3๊ฐ์ง์ด๋ค.1. ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ ์ฅ ๋ฐ ์ ๊ทผ2. ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ ์ต์ ํ3. ๋ฌธ์ ํด๊ฒฐ ๋ฐ ์๊ณ ๋ฆฌ์ฆ ์ค๊ณ ์ง์๊ฐ๊ฐ ๋ค๋ฅธ ์ฑ
์ฅ์ด ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํ์.1๋ฒ ์ฑ
์ฅ์ ์ฑ
์ด ๋ฌด์์๋ก ๊ฝํ ์๊ธฐ ๋๋ฌธ์ ๋์ค์ ์ํ๋ ์ฑ
์ ์ฐพ๊ธฐ๊ฐ ์ด๋ ค์ธ ์ ์๋ค.2๋ฒ ์ฑ
์ฅ์ ์นธ๋ง๋ค ๊ฐ์ ์์์ ์ฑ
์ ์ง์ดํ๋ค. ..
[์๊ณ ๋ฆฌ์ฆ ํจ์จ์ฑ] ์๊ฐ ๋ณต์ก๋์ ๊ณต๊ฐ ๋ณต์ก๋ ๊ทธ๋ฆฌ๊ณ ์ ๊ทผ์ ํ๊ธฐ๋ฒ ์ด์ ๋ฆฌ
์๊ณ ๋ฆฌ์ฆ ํจ์จ์ฑ ์ฒดํฌ์์ ์ฐ์ด๋ ์๊ฐ ๋ณต์ก๋์ ๊ณต๊ฐ ๋ณต์ก๋, ๊ทธ๋ฆฌ๊ณ Big-O ํ๊ธฐ๋ฒ์ ๋ํด ์ ๋ฆฌํ๊ณ ๋์ด๊ฐ๊ณ ์ ํ๋ค.์ฝํ
์์ ์ด๋์ ๋ ๊ตฌํ์ ํ๋ค๋ณด๋ฉด ์๊ฐ ์ด๊ณผ ํน์ ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ๋ฅผ ๊ฒช๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.๊ทธ ๋ ์ด๋ค ๊ณณ์ ์ต์ ํํ๋ฉด ์ข์์ง ์๊ณ ์ ๊ฒธ์ฌ๊ฒธ์ฌ ์ ๋ฆฌํ๊ณ ๋์ด๊ฐ๊ธฐ๋ก ํ๋ค.์ ๋์ ๋ชจ๋ฅผ ๋์ ์ฝ๋ ๊ตฌํ์ ์ ๋ง ๋ฌ๋ผ์ง ๊ฒ์ด๋ค. ๐ ๋ณต์ก๋ & ์ ๊ทผ์ ํ๊ธฐ๋ฒ ๋ณต์ก๋, ๊ทธ๊ฒ์ด ๋ฌด์์ธ๊ฐ ๐ง์ปดํจํฐ ๊ณผํ์์ ์๊ณ ๋ฆฌ์ฆ์ ๊ณ์ฐ ๋ณต์ก๋(Computational Complexity) ํน์ ๋ณต์ก๋(Complexity)๋ผ๋ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ์คํํ๋ ๋ฐ ํ์ํ ์์์ ์์ ๋ปํ๋ค.์ด๋ ๊ณณ ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ์ธก์ ํ๋ ๋ฐ ์ฌ์ฉ๋๊ณ , ๋ณต์ก๋๊ฐ ์์ผ๋ฉด ์์ ์๋ก ํด๋น ์๊ณ ๋ฆฌ์ฆ์ด ํจ์จ์ ์ด๋ผ๊ณ ํ๋จํ๋ค.์ฌ๋ฌ ๋ณต์ก๋๊ฐ ์์ง๋ง ๋ํ์ ์ธ..
1. ํ (Queue)ํ๋ ์ด๋ ๊ฒ ์ ์
์ ์ถ(FIFO) ๊ตฌ์กฐ์ด๋ค.์ฐ์ฐ ๊ณผ์ ์๋- enqueue : ํ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๋ ์์
- dequeue : ํ์์ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด๋ ์์
- front : ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด๋ ๋ถ๋ถ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐํ- rear : ๋ฐ์ดํฐ๋ฅผ ๋ฃ๋ ๋ถ๋ถ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐํ์ด๋ฐ ๊ฐ๋
๋ค์ด ๋ฑ์ฅ ํ๋ค. 1. ์ฝ๊ฒ ์ดํด๋ฅผ ์ํด ์์ ๋ฅผ ์ดํด ๋ณด๊ฒ ๋ค.์ฐ๋ฆฌ๊ฐ ์ค ์์๋ ๋๊ธฐ์ด์ ์๊ฐํ๋ฉด ์ฝ๋ค.ํฐ์ผ ๋งคํ์์ ์ด๋ ๊ฒ ์ค์ ์ ์๋ค๊ณ ๊ฐ์ ํด๋ณด์.์ค์ ์ ์ผ ๋จผ์ ์ A๊ฐ ๋จผ์ ํ๋ฅผ ์ฌ๊ณ , ์ ์ผ ๋์ค์ ์ E๊น์ง ๋ชจ๋ ์์๋๋ก ํ๋ฅผ ์ด ์ ์์ ๊ฒ์ด๋ค.์ด๋ ๊ฒ ๊ทผ๋ฐ ์ฌ๊ธฐ์ F๊ฐ ๋ฑ์ฅํด์ ์ค์ ์ ๋ค.๊ทธ๋ผ ์ด๋ rear๋ ์๋ก ์ถ๊ฐ๋ ๋งจ ๋ค์ F๋ก ๋๋ค.์ด F๋ฅผ ์ถ๊ฐํ๋ ์์
์ enqueue ๋ผ๊ณ ํ๊ณ , F ์ถ๊ฐํ ์์น๋ฅผ ๋ํ๋ด๋..
์ฌ๊ท ํจ์ ์ด์ฉํด์ ๊ตฌํ๋ ์ฝ๋ def solution(x): answer = 0 if x =2: fn = fn_1 + fn_2 fn_2 = fn_1 fn_1 = fn x -= 1 return fn ๋ฐ๋ณต๋ฌธ ๋ฒ์ ์ ํ๋ก๊ทธ๋๋จธ์ค์ ๋ค๋ฅธ ์ฌ๋ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ๋ค ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ์ ํจ์จ์ฑ์ด ๋จ์ด์ง ๊ฐ๋ฅ์ฑ์ด ํฌ์ง๋ง ์๊ฐ์ ์ง๊ด์ ์ผ๋ก ํํ์ด ๊ฐ๋ฅํ๋ค๋ ์ฅ์ ์ด ์๋ค
์ด์งํ์์ ๊ผญ ํฌ๊ธฐ์์ผ๋ก ์ ๋ ฌ๋์ด์๋ค๋ ์ฑ์ง์ ์ด์ฉํ์ฌ ํ์ํ๋ ๊ธฐ๋ฒ def solution(L, x): start = 0 upper = len(L) -1 answer = -1 while start
ํน์ ์์๋ฅผ ํฌํจํ ์ธ๋ฑ์ค ๋ชจ๋ ๋ฐํํ๋ ๋ฌธ์ , ๋ง์ฝ์ ์์ ์์ ๋ฆฌํด๊ฐ์ -1์ ๋ฃ์ด์ ๋ฐํํ๋ค. def solution(L, x): answer = [] i = 0 while i < len(L): if L[i] == x: answer.append(i) i += 1 if answer == [] : answer = [-1] return answer ์ด๊ฑด ๋์ค์ ์ค๋ฌด์์๋ ์ ์ ํ ์จ๋จน์ ์ ์์๊ฑฐ ๊ฐ์์ ๊ธฐ๋ก ํํ! ์ข๋ ์์ธ์ฒ๋ฆฌ๋ฅผ ํ์ง ์๊ณ ๊น๋ํ๊ฒ ์ง๋ ์ฐ์ต์ ํด์ผํ ๊ฒ ๊ฐ๋ค