๐งฉ <์ฝ๋ฉํ ์คํธ ํฉ๊ฒฉ์ ๋๊ธฐ: ํ์ด์ฌ ํธ> 1๋ ์คํฐ๋ ๊ธฐ๋ก์ ๋๋ค.
์ ์ธ
์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ
arr = [0, 0, 0, 0, 0]
arr = [0] * 5
๋ฆฌ์คํธ ์์ฑ์๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
arr = list(range(5))
# ๊ฒฐ๊ณผ: arr = [0, 1, 2, 3, 4]
List Comprehension์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
List Comprehension์ด๋, [expression for item in iterable if condition] ๊ตฌ์กฐ๋ก ๋ฆฌ์คํธ๋ฅผ ๊ฐ๊ฒฐํ๊ณ ํจ์จ์ ์ผ๋ก ์์ฑํ ์ ์๋ ๋ฌธ๋ฒ์ด๋ค. ์ฝ๋์ ๊ฐ๋ ์ฑ์ ๋์ด๊ณ ์ผ๋ฐ์ ์ธ for ๋ฃจํ๋ณด๋ค ๋น ๋ฅด๊ฒ ์คํํ ์ ์๋ค.
arr = [0 for _ in range(5)]
# ๊ฒฐ๊ณผ: arr = [0, 0, 0, 0, 0]
์๊ฐ ๋ณต์ก๋
๋งจ ๋ค์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ
ํด๋น ์์น์ ๋ฐ๋ก ์ ๊ทผํ ์ ์๊ณ ๋ค๋ฅธ ๋ฐ์ดํฐ์ ์์น์ ์ํฅ์ ์ฃผ์ง ์๊ธฐ ๋๋ฌธ์ $ O(1) $์ด๋ค.
๋งจ ์์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ
๊ธฐ์กด์ ์๋ ๋ฐ์ดํฐ๋ค์ ๋ชจ๋ ํ ์นธ์ฉ ๋ฏธ๋ฃจ๊ธฐ ์ํ ์ฐ์ฐ์ด ํ์ํ๋ฏ๋ก $ O(N) $์ด๋ค.
์ค๊ฐ์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ
์ฝ์ ์์น์ ๋ค์ ์๋ ๋ฐ์ดํฐ๋ค์ ๋ชจ๋ ํ ์นธ์ฉ ๋ฏธ๋ฃจ๋ ์ฐ์ฐ์ด ํ์ํ๋ฏ๋ก ๋ง์ฐฌ๊ฐ์ง๋ก $ O(N) $์ด๋ค.
๊ณ ๋ คํ ์
๋ฐฐ์ด์ ๋ฐ์ดํฐ์ ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํด์ ๋ฐ๋ก ์ ๊ทผํ ์ ์๋ค๋ ์ฅ์ ์ด ์๋ค. ๋ฐ๋ผ์ ๋ฐ์ดํฐ์ ์์ฃผ ์ ๊ทผํด์ผ ํ๋ค๋ฉด ํจ์จ์ ์ด๋ค. ๋ฐ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๊ฐ ๋ฐ์ํ ์๋ ์์ผ๋ฏ๋ก ์๋ ์ฌํญ์ ๊ณ ๋ คํด์ผ ํ๋ค.
- ํ ๋น ๊ฐ๋ฅํ ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ๋ฅผ ํ์ธํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ ์ํ 1์ฐจ์ ๋ฐฐ์ด์ 1000๋ง, 2์ฐจ์ ๋ฐฐ์ด์ 3000*3000 ํฌ๊ธฐ๋ฅผ ์ต๋๋ก ์ค์ ํ๋ค.
- ๋งจ ์ ๋๋ ์ค๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์ง ํ์ธํ๋ค.
- ๋งจ ์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํด์ผ ํ๋ ๊ฒฝ์ฐ deque๋ฅผ ํ์ฉํ๋ฉด $ O(1) $์ ์ฑ๋ฅ์ ๋ณด์ฅํ ์ ์๋ค.
์ ์ฉํ ๊ธฐ๋ฒ
์๋์ ๊ฐ์ด ์ ์ธ๋ ๋ฆฌ์คํธ my_list๋ฅผ ๊ฐ์ง๊ณ ์์ฃผ ์ฌ์ฉ๋๋ ๋ฆฌ์คํธ ๊ธฐ๋ฒ์ ์ ๋ฆฌํด๋ณด์.
my_list = [1, 2, 3]
๋ฐ์ดํฐ ์ถ๊ฐ
๋งจ ๋์ ๋ฐ์ดํฐ ์ฝ์
my_list.append(4)
# ๊ฒฐ๊ณผ: my_list = [1, 2, 3, 4]
' + ' ์ฐ์ฐ์ ์ฌ์ฉ
my_list = my_list + [4, 5]
# ๊ฒฐ๊ณผ: my_list = [1, 2, 3, 4, 5]
ํน์ ์์น์ ๋ฐ์ดํฐ ์ฝ์
my_list.insert(2, 17)
# ๊ฒฐ๊ณผ: my_list = [1, 2, 17]
๋ฐ์ดํฐ ์ญ์
ํน์ ์์น์ ๋ฐ์ดํฐ ํ
pop์ ๋ฆฌ์คํธ์์ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ ๋ฟ๋ง ์๋๋ผ ์ญ์ ํ ๋ฐ์ดํฐ์ ๊ฐ์ ๋ฐํํ๋ค.
popped_number = my_list.pop(2)
# my_list = [1, 2]
# popped_number = 3
ํน์ ๋ฐ์ดํฐ ์ญ์
ํน์ ์์น๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ ๊ฒ์ด ์๋, ํน์ ๊ฐ์ด ์ฒ์ ๋ฑ์ฅํ๋ ์์น์ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ค.
my_list.remove(3)
# ๊ฒฐ๊ณผ: my_list = [1, 2]
List Comprehension
์๋์ ๋ฐฉ๋ฒ์ผ๋ก ๊ธฐ์กด ๋ฆฌ์คํธ์ ๋ชจ๋ ๋ฐ์ดํฐ์ ์ ๊ณฑ์ฐ์ฐ์ ํ ์๋ก์ด ๋ฆฌ์คํธ๋ฅผ ์์ฑํ ์ ์๋ค. ๊ธฐ์กด ๋ฆฌ์คํธ๋ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
square_list = [num**2 for num in my_list]
# my_list = [1, 2, 3]
# square_list = [1, 4, 9]
๊ธฐํ
ํน์ ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ์ฒ์ ๋ฑ์ฅํ ์ธ๋ฑ์ค๋ฅผ ๋ฐํ
ํด๋น ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ๋ฆฌ์คํธ์ ์กด์ฌํ์ง ์์ผ๋ฉด -1์ ๋ฐํํ๋ค.
my_list.index(2) # 1
my_list.index(0) # -1
์ ๋ ฌ
์ธ์๋ฅผ ์ ๋ฌํ์ง ์์ผ๋ฉด ์ค๋ฆ์ฐจ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๋ค. ์๋๋ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ด๋ค.
my_list.sort(reverse=True)
# my_list = [3, 2, 1]
ํน์ ๊ฐ์ ๋ฐ์ดํฐ ๊ฐ์ ์ธ๊ธฐ
my_list.count(1) # 1
๐ Reference
์ฝ๋ฉ ํ ์คํธ ํฉ๊ฒฉ์ ๋๊ธฐ: ํ์ด์ฌ ํธ, ๋ฐ๊ฒฝ๋ก, ๊ณจ๋ ๋๋น.
'Study > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
06. ์คํ (1) | 2024.01.21 |
---|---|
04. ์ฝ๋ฉ ํ ์คํธ ํ์ ๋ฌธ๋ฒ(Python) (3) | 2024.01.06 |
03. ์๊ณ ๋ฆฌ์ฆ์ ํจ์จ ๋ถ์ (0) | 2024.01.06 |