[Data Structures] LinkedList - Removing Values
Removing Values
์ด๋ฒ์ LinkedList์ ๊ฐ์ ์ ๊ฑฐํ๋ ์ฝ๋๋ฅผ ํ์ธ!
๊ฐ ์ ๊ฑฐ์๋ ์ธ ๊ฐ์ง๊ฐ ์๋ค.
- ์์์ ๋นผ๊ธฐ(pop),
- ๋ค์์ ๋นผ๊ธฐ(removeLast),
- ์ด๋ค ๊ฐ ๋ฐ๋ก ๋ค์ ์๋ ๋ ธ๋๋ฅผ ๋นผ๊ธฐ(remove(at:)).
์ ํฌ์คํ ์์๋ ๋งํฌ๋๋ฆฌ์คํธ์์ ๊ฐ์ ์ ๊ฑฐํ๋ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๊ฐ๊ฐ ๊ตฌํํด๋ณด๊ณ ์๊ฐ๋ณต์ก๋๋ ์์๋ณด๋๋ก ํ๋ค.
pop ๊ตฌํํด๋ณด๊ธฐ
pop์ ์ด๋ค ๊ฐ์ LinkedList์ ๊ฐ์ฅ ์์์ ์ ๊ฑฐํ๋ค. push์ ๋น์ทํ๊ณ ์ฝ๋ค.
push๋ฅผ ๊ตฌํํด๋ณด์.
mutating func pop() -> T? {
defer {
self.head = head?.next
if self.isEmpty { self.tail = nil }
}
return self.head?.value
pop์ ๊ตฌํํ ๋ ์ ๊ฑฐ๋๋ ๋ ธ๋์ value๋ฅผ ๋ฆฌํดํ๋๋ก ํ๋ค. list๊ฐ ๋น์ด์์ ์๋ ์๊ธฐ ๋๋ฌธ์ value๋ ์ต์ ๋๋ก ๋ฆฌํด๋๋ค.
pop์ head ๋ ธ๋๋ฅผ ์ ๊ฑฐํ๊ณ ๊ทธ head์ next ๋ ธ๋๊ฐ head๊ฐ ๋๋ ์ผ์ด๋ฏ๋ก ARC๋ ์ด ๋ฉ์๋๊ฐ ๋๋๋ฉด pop๋ ๋ ธ๋๋ฅผ ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐํ๋ค. (๋์ด์ ์ฐธ์กฐํ์ง ์์ผ๋ฏ๋ก?)
defer์์ ๋ชฉ๋ก์ด ๋น์ด์๊ฒ ๋๋ ๊ฒฝ์ฐ tail์ nil๋ก ์ค์ ํด์ ํน์๋ ๋จ์์์ ๋ชจ๋ ์ฐธ์กฐ๋ฅผ ์ ๊ฑฐํด๋ฒ๋ฆฐ๋ค.
๋ง์ง๋ง insert ๋ฉ์๋ ์ดํ pop์ ์คํํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด 2 - 10000 - 3
๋ง ๋จ๊ฒ ๋๋ค.
removeLast ๊ตฌํํด๋ณด๊ธฐ
removeLast๋ ์ฝ๊ฐ ์ฝ๋๊ฐ ๊ธธ์ด์ง๋ค. tail ๋ ธ๋๋ฅผ ๋นผ๊ณ ๊ทธ ์์ ๊ฐ์ tail๋ก ์ง์ ํ๋ฉด ๋์ง ์๋?! ํ ์๋ ์์ง๋ง ์ฐ๋ฆฌ๊ฐ ๊ตฌํํ๊ณ ์๋ LinkedList๋ prev์ ๊ฐ์ ๊ฐ์ง๊ณ ์์ง ์๊ธฐ ๋๋ฌธ์ tail ๋ ธ๋์ ์ด์ ๋ ธ๋๋ฅผ ์์ง ๋ชปํ๋ค.
๊ทธ๋์ list๋ฅผ ์ํํด์ ๋ง์ง๋ง ๋ ธ๋์ ๊ทธ ์ ๋ ธ๋๋ฅผ ์์๋ด์ผ ํ๋ค.
mutating func removeLast() -> T? {
guard let head = self.head else { return nil }
guard head.next != nil else { return self.pop() }
var prev = self.head
var current = self.head
while let next = current?.next {
prev = current
current = next
}
prev?.next = nil
self.tail = prev
return current?.value
}
- head๊ฐ ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ๋ linkedlist๊ฐ ๋น์ด์๋ค๋ ๋ป์ด๋ฏ๋ก nil์ return ํ๋ค.
- head.next๊ฐ ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ head ํ๋๋ง ๋จ์๋ค๋ ๋ป์ด๋ฏ๋ก pop์ผ๋ก head์ ๋ ธ๋๋ฅผ ์ ๊ฑฐํ๋ค.
- ์ดํ ๋ฆฌ์คํธ์ ๋ง์ง๋ง๊น์ง while๋ฌธ์ผ๋ก ๋๋ฉด์ tail๊ณผ tail์ ์ ๋ ธ๋๋ฅผ ์์๋ธ๋ค.
- tail์ ๊ฐ์ return ํ๊ณ tail์ ์ ๋ ธ๋๋ฅผ tail๋ก ๋ณ๊ฒฝํ๋ค.
์ ์ฝ๋์ ์ด์ด์ removeLast๋ฅผ ์คํํ๋ฉด ๊ฐ์ฅ ๋ง์ง๋ง value์ธ 3์ด ์ ๊ฑฐ๋๊ณ 2 - 10000
์ด ๋จ๋๋ค.
remove(after:) ๊ตฌํํด๋ณด๊ธฐ
remove(after:) ๋ ์ํ๋ ๋ ธ๋ ๋ค์์ ๋ ธ๋๋ฅผ ์ ๊ฑฐํ๋๋ก ๊ตฌํํด์ผ ํ๋ค. ์์๋ฅผ ๋ฐ์ง๋ฉด ์ด๋ ๋ค.
- ๋ฆฌ์คํธ์์ ํน์ ๋ ธ๋๋ฅผ ์ฐพ๋๋ค. (์ํ๋ ๊ฐ์ด ์์ ์๋ ์๋ค.)
- ํน์ ๋ ธ๋ ๋ค์(.next)์ ์ ๊ฑฐํ๋ค.
1๋ฒ์ ๊ฒฝ์ฐ๋ ์์ insert(after:) ๋ฉ์๋๋ฅผ ๊ตฌํํ ๋ ์ฌ์ฉํ node ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
mutating func remove(after node: Node<T>) -> T? {
defer {
if node.next === tail {
tail = node
}
node.next = node.next?.next
}
return node.next?.value
}
๊ธฐ๋ณธ์ ์ผ๋ก๋ node์ ๋ค์ value๋ฅผ return ํ๋ค. ๋ง์ฝ ํน์ ๋ ธ๋์ ๋ค์์ด tail์ด๋ผ๋ฉด tail์ ์ ๊ฑฐํ๊ฒ ๋๋ ๊ผด์ด ๋๋ฏ๋ก tail์ ๊ฐ์ ํ์ฌ node๋ก ๋์ฒดํ๋ค. ๊ทธ ํ node์ ๋ค์์ ์ ๊ฑฐ๋๋ฏ๋ก node.next๋ ๋ค์์ ๋ค์ ๋ ธ๋๊ฐ ๋๋๋ก ๋ณ๊ฒฝํ๋ค.
removeLast() ๋ฉ์๋ ๋ค์์ 1, 2๋ฅผ push๋ก ์ง์ด๋ฃ์ด 2 - 1 - 2 - 10000
์ผ๋ก ๋ง๋ ๋ค 1๋ฒ Index์ ๋
ธ๋ ๋ค์์ ์ ๊ฑฐํ๋๋ก ํ๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก 2 - 1 - 10000
์ผ๋ก 1๋ฒ index์ธ 1 ๋ค์ ๊ฐ์ด ์ ๊ฑฐ๋์๋ค.
์๊ฐ๋ณต์ก๋ ์ ๋ฆฌ
pop๊ณผ remove(after:)์ ์ํ๋ ์์น์ ๋ ธ๋๋ฅผ ํ๋ฒ์ ์ ๊ฑฐํ๋ฏ๋ก O(1)์ด๊ณ removeLast๋ tail๊ณผ tail์ ์ ๋ ธ๋๋ฅผ ์ฐพ์์ผํด์ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๋ฏ๋ก O(n)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
๋ค์์๊ฐ์๋ Remove๋กโฆ.!!!
Leave a comment