์ฐ๊ฒฐ๋ฆฌ์คํธ๋ ๋ค๋ฅธ ์ถ์ ์๋ฃํ(Abstract Data Type)์ ๊ตฌํํ ๋ ๊ธฐ๋ฐ์ด ๋๋ ๊ธฐ์ด ์ ํ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
๊ฐ ๋ ธ๋๊ฐ ๋ฐ์ดํฐ์ ํฌ์ธํฐ๋ฅผ ๊ฐ์ง๊ณ ํ ์ค๋ก ์ฐ๊ฒฐ๋์ด ์๋ ๋ฐฉ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ค. ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ๋๋๋ฌ์ง๋ ํน์ง๋ค์ ๋ฐฐ์ด๊ณผ ๋น๊ตํด์ ๋ณด๋ฉด ์ข๋ค.
์ถ์ฒ: <ํ์ด์ฌ ์๊ณ ๋ฆฌ์ฆ ์ธํฐ๋ทฐ> p.199, ์ฑ ๋ง, 2020
O(n)
์ ์๊ฐ์ด ๊ฑธ๋ฆฌ์ง๋ง, ๋์ ์ผ๋ก ์ฐ๊ฒฐ๋ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ย ์ฝ์
/์ญ์ ์ย O(1)
์ด ๊ฑธ๋ฆฐ๋ค.O(1)
์ ์๊ฐ์ผ๋ก ์์ฝ๊ฒ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฌ๋ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ย O(n)
์ ์๊ฐ์ด ์์๋๋ค. (๋ฐฐ์ด๊ณผ ๋ค๋ฅด๊ฒย ์ฐ๊ฒฐ๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์๋๊ธฐ ๋๋ฌธ์, ๋ฐ์ดํฐ๋ฅผ ์ฐพ๊ธฐ ์ํด์๋ ๋ชจ๋ ๋
ธ๋๋ฅผ ๊ฑฐ์ณ์ ํ์ํด์ผ ํ๋ค.)์ฐ๊ฒฐ๋ฆฌ์คํธ์๋ ์ฑ๊ธ ์ฐ๊ฒฐ๋ฆฌ์คํธ(Singly Linked List), ๋๋ธ ์ฐ๊ฒฐ๋ฆฌ์คํธ(Doubly Linked List), ์ํ ์ฐ๊ฒฐ๋ฆฌ์คํธ(Circular Linked List)๊ฐ ์๋ค.๊ทธ ์ค ์ด ๊ธ์์๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์ฑ๊ธ ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ๋ํด ๋ค๋ฃฐ ์์ ์ด๋ค.
์๋ฃ๊ตฌ์กฐ์ ๋ํ ๊ตฌํ๋ณด๋ค๋ ๊ฐ๋จํ๊ฒ ์ฐ๊ฒฐ ๊ฐ๋ฅํ ๋ ธ๋๋ง ์ ์ํด์ ๋ ธ๋๋ฅผ ๊ฐ์ง๊ณ ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ๋์์ ์ดํด ๋ณด๋ คํ๋ค.
์์ธํ ๊ตฌํ์ย ํ์ด์ฌ์ผ๋ก ๊ตฌํํ ์๋ฃ๊ตฌ์กฐ - ์ฐ๊ฒฐ ๋ฆฌ์คํธย ํน์ย ํ์ด์ฌ ์๋ฃ๊ตฌ์กฐ 8-1์ฅ. ์ฐ๊ฒฐ ๋ฆฌ์คํธย ๊ธ์ ์ฐธ๊ณ ํ์ธ์.
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
๋ณดํต ํค๋๋ฅผ ์ ์ธํ์ฌ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ์์ฑํ๊ณ ,ํค๋๋ฅผ ํตํด ๋ค๋ฅธ ๋ชจ๋ ๋
ธ๋๋ฅผ ํ์ํ๊ณ ์ฐธ์กฐํ ์ ์๋ค.๋ฐ๋ผ์,ย head
๋ฅผ ์ง์ ์ด๋์ํค์ง ์๊ณ ,ย node=head
๋กย head
์ฃผ์๋ฅผ ์ฐธ์กฐํ์ฌ ์ฌ์ฉํ๋ค.(์๋ ํค๋๋ data๋ฅผ ํฌํจํ๊ณ ์์ง ์์ผ๋ฉฐ, ํค๋์ ๋ค์ ๋
ธ๋๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๋ ํธ์์ ์์์ ๊ฐ์ ๋ฃ๊ณ ๋ค์ ๋
ธ๋๋ถํฐ ์ฌ์ฉํด๋ ๋๊ณ ,ย head
๋
ธ๋ ๋ถํฐ ์ฌ์ฉํด๋ ๋๋ค.)
head = ListNode(0)
#add new_node
curr_node = head
new_node = ListNode(1)
curr_node.next = new_node
curr_node=curr_node.next
curr_node.next = ListNode(2)
curr_node=curr_node.next
curr_node.next = ListNode(3)
curr_node=curr_node.next
curr_node.next = ListNode(4)
curr_node=curr_node.next
#print all node
node=head
while node:
print(node.val)
node=node.next
''' ์ถ๋ ฅ๊ฒฐ๊ณผ : 0,1,2,3,4 '''
#delete node by value
node=head
while node.next:
if node.next.val==2:
next_node=node.next.next
node.next=next_node
break
node=node.next
node=head
while node:
print(node.val)
node=node.next
''' ์ถ๋ ฅ๊ฒฐ๊ณผ : 0,1,3,4 '''