[파이썬][자료구조] 링크드 리스트 (Linked List)

링크드 리스트 (Linked List) 구조

• 연결 리스트라도 한다.
• 배열은 연속된 공간을 예약해 놓고 데이터를 나열하는 구조이다.
• 링크드 리스트는 미리 공간을 예약하지 않고 필요할 때마다 데이터를 추가할 수 있는 구조이다. 배열의 단점을 극복한 구조이다.

• 노드 (node) : 데이터 + 다음 데이터를 가리키는 주소 (포인터)가 하나의 데이터로 구성
• 포인터 (pointer): 다음 데이터를 가리키는 주소 값
• 노드 단위로 아무 공간이나 데이터를 저장을 해놓고 포인터를 이용하여 연결한다.

 

링크드 리스트 구현

# data가 2개이기 때문에 class가 유리
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Node:
    def __init__ (self, data, next = None):
        self.data = data
        self.next = next

node와 node 연결하기 (포인터 활용)

node1 = Node("Estus Flask")
node2 = Node("Ashen Estus Flask")
node1.next = node2
head = node1

링크드 리스트로 node 추가하기

class Node:
    def __init__(self, data, next=None):
        self.data = data
        self.next = next

def add(data):
    node = head
    while node.next:    # node의 끝이 어디인지
        node = node.next
    node.next = Node(data) # 이때의 node는 다음 데이터 주소가 없는 node이며 여기에 새로운 node를 연결한다.

item_list = ["Ashen Estus Flask", "Estus Shard", "Undead Bone Shard", "Homeward Bone"]
node1 = Node("Estus Flask")
head = node1
for item in item_list:
    add(item)

링크드 리스트 node 출력

node = head
while node.next:
    print(node.data) # 현재 node 데이터
    node = node.next # 다음 node로 이동
print(node.data) # 마지막 node 출력

Estus Flask
Ashen Estus Flask
Estus Shard
Undead Bone Shard
Homeward Bone

링크드 리스트의 장단점

• 장점
  • 미리 데이터 공간 할당하지 않아도 된다 (배열은 미리 해야 함).
• 단점
  • 연결을 위한 데이터가 하나 더 필요하기 때문에 저장공간 효율이 좋지 않다.
  • Index를 이용한 배열과는 다르게 특정한 데이터를 찾는데 시간이 필요해 접근 속도가 느리다.
  • 중간에 있는 데이터를 추가 및 삭제가 불편하다 (연결을 재구성해야 하기 때문).

링크드 리스트 사이에 node 추가

node = head
while node.next:
    print(node.data) # 현재 node 데이터
    node = node.next # 다음 node로 이동
print(node.data) # 마지막 node 출력

Estus Flask
Ashen Estus Flask
Estus Shard
Undead Bone Shard
Homeward Bone

node3 = Node("Fading Soul")

node = head
search = True
while search:
    if node.data == "Estus Flask":
        search = False
    else:
        node = node.next
node_next = node.next
node.next = node3
node3.next = node_next

node = head
while node.next:
    print(node.data) # 현재 node 데이터
    node = node.next # 다음 node로 이동
print(node.data) # 마지막 node 출력

Estus Flask
Fading Soul
Ashen Estus Flask
Estus Shard
Undead Bone Shard
Homeward Bone

파이썬 객체지향 프로그래밍으로 링크드 리스트 구현

class Node:
    def __init__(self, data, next=None):
        self.data = data
        self.next = next

class NodeMgmt:
    def __init__(self, data):
        self.head = Node(data)

    def add(self, data):
        if self.head == '':
            self.head = Node(data)
        else:
            node = self.head
            while node.next:
                node = node.next
            node.next = Node(data)

    def desc(self):
        node = self.head
        while node:
            print(node.data)
            node = node.next

linkedlist1 = NodeMgmt("Estus Flask")
linkedlist1.desc()

Estus Flask

item_list = ["Ashen Estus Flask", "Estus Shard", "Undead Bone Shard", "Homeward Bone"]
for item in item_list:
    linkedlist1.add(item)
linkedlist1.desc()

Estus Flask
Ashen Estus Flask
Estus Shard
Undead Bone Shard
Homeward Bone

특정 node를 삭제

삭제하고자 할 때 다음과 같은 경우를 생각해야 한다.

1. head를 삭제
2. 마지막 node 삭제
3. 중간 node를 삭제

class Node:
    def __init__(self, data, next=None):
        self.data = data
        self.next = next

class NodeMgmt:
    def __init__(self, data):
        self.head = Node(data)

    def add(self, data):
        if self.head == '':
            self.head = Node(data)
        else:
            node = self.head
            while node.next:
                node = node.next
            node.next = Node(data)

    def desc(self):
        node = self.head
        while node:
            print(node.data)
            node = node.next

    def delete(self, data):
        if self.head == '':
            print("노드 없음")
            return

        if self.head.data == data: # 1번째 경우
            temp = self.head
            self.head = self.head.next # 두번째 node가 head가 됨.
            del temp
        else: # 2, 3번째 경우
            node = self.head
            while node.next:
                if node.next.data == data:
                    temp = node.next
                    node.next = node.next.next
                    del temp
                    return
                else:
                    node = node.next

linkedlist1 = NodeMgmt("Estus Flask")
linkedlist1.desc()

Estus Flask

linkedlist1.head

<__main__.Node at 0x26405533648>

# head 삭제
linkedlist1.delete("Estus Flask")

linkedlist1.head

아무것도 출력 안됨.

linkedlist1 = NodeMgmt("Estus Flask")
item_list = ["Ashen Estus Flask", "Estus Shard", "Undead Bone Shard", "Homeward Bone"]
for item in item_list:
    linkedlist1.add(item)
linkedlist1.desc()

Estus Flask
Ashen Estus Flask
Estus Shard
Undead Bone Shard
Homeward Bone

# 중간 node 제거
linkedlist1.delete("Estus Shard")

linkedlist1.desc()

Estus Flask
Ashen Estus Flask
Undead Bone Shard
Homeward Bone

# 마지막 node 제거
linkedlist1.delete("Homeward Bone")

linkedlist1.desc()

Estus Flask
Ashen Estus Flask
Undead Bone Shard

중간 삽입 및 node 찾는 기능 추가

class Node:
    def __init__(self, data, next = None):
        self.data = data
        self.next = next

class NodeMgmt:
    def __init__(self, data):
        self.head = Node(data)

    def add(self, data): # 맨 뒤에 추가
        if self.head == '':
            self.head = Node(data)
        else:
            node = self.head
            while node.next:
                node = node.next
            node.next = Node(data)

    def insert(self, data, insert_data): # 중간에 삽입
        if self.head == None:
            self.head = Node(insert_data)

        else:
            node = self.head
            search = True
            while search:
                if node.data == data:
                    search = False
                else:
                    node = node.next
            node_next = node.next
            node.next = Node(insert_data)
            node.next.next = node_next

    def desc(self): #출력
        node = self.head
        while node:
            print(node.data)
            node = node.next

    def delete(self, data): #삭제
        if self.head == '':
            print("No data")
            return

        if self.head.data == data:
            temp = self.head
            self.head = self.head.next
            del temp

        else:
            node = self.head
            while node.next:
                if node.next.data == data:
                    temp = node.next
                    node.next = node.next.next
                    del temp
                    return
                else:
                    node = node.next

    def search(self, data): #찾기
        node = self.head
        while node:
            if node.data == data:
                return node
            else:
                node = node.next
        return False

item_list = ["Ashen Estus Flask", "Estus Shard", "Undead Bone Shard", "Homeward Bone"]
linkedlist = NodeMgmt("Estus Flask")
for item in item_list:
    linkedlist.add(item)
linkedlist.desc()

Estus Flask
Ashen Estus Flask
Estus Shard
Undead Bone Shard
Homeward Bone

linkedlist.insert("Estus Shard", "Harbel")
linkedlist.desc()

Estus Flask
Ashen Estus Flask
Estus Shard
Harbel
Undead Bone Shard
Homeward Bone

item = linkedlist.search("Estus Shard")
print(item.data)

Estus Shard

다양한 링크드 리스트 구조

• 더블 링크드 리스트 (Doubly linked list) 구조
  • 장점 : 양방향으로 연결되어있어 노드 탐색이 양쪽으로 가능하여 데이터를 좀 더 효율적으로 찾을 수 있다.
  • 단점 : 복잡함

class Node:
    def __init__(self, data, prev=None, next=None):
        self.prev = prev
        self.data = data
        self.next = next

class NodeMgmt:
    def __init__(self, data):
        self.head = Node(data)
        self.tail = self.head # node가 1개면 head = tail

    def add(self, data):
        if self.head == None:
            self.head = Node(data)
            self.tail = self.head
        else:
            node = self.head
            while node.next:
                node = node.next
            new = Node(data)
            node.next = new
            new.prev = node
            self.tail = new

    def desc(self):
        node = self.head
        while node:
            print(node.data)
            node = node.next        

double_linkedlist = NodeMgmt("Estus Flask")
item_list = ["Ashen Estus Flask", "Estus Shard", "Undead Bone Shard", "Homeward Bone"]
for item in item_list:
    double_linkedlist.add(item)
double_linkedlist.desc()

Estus Flask
Ashen Estus Flask
Estus Shard
Undead Bone Shard
Homeward Bone

head에서부터 tail, tail에서부터 head로 이동하면서 원하는 node 찾는 기능 추가

class Node:
    def __init__(self, data, prev=None, next=None):
        self.prev = prev
        self.data = data
        self.next = next

class NodeMgmt:
    def __init__(self, data):
        self.head = Node(data)
        self.tail = self.head # node가 1개면 head = tail

    def add(self, data):
        if self.head == None:
            self.head = Node(data)
            self.tail = self.head
        else:
            node = self.head
            while node.next:
                node = node.next
            new = Node(data)
            node.next = new
            new.prev = node
            self.tail = new

    def desc(self):
        node = self.head
        while node:
            print(node.data)
            node = node.next

    def search_from_head(self, data):
        if self.head == None:
            return False

        node = self.head
        while node:
            if node.data == data:
                return node
            else:
                node = node.next
        return False

    def search_from_tail(self, data):
        if self.head == None:
            return False
        node = self.tail
        while node:
            if node.data == data:
                return node
            else:
                node = node.prev
        return False

double_linkedlist = NodeMgmt("Estus Flask")
item_list = ["Ashen Estus Flask", "Estus Shard", "Undead Bone Shard", "Homeward Bone"]
for item in item_list:
    double_linkedlist.add(item)
double_linkedlist.desc()

Estus Flask
Ashen Estus Flask
Estus Shard
Undead Bone Shard
Homeward Bone

node3 = double_linkedlist.search_from_tail("Estus Shard")
node3.data

'Estus Shard'

특정 node 뒤 또는 앞에 node 추가

class Node:
    def __init__(self, data, prev = None, next = None):
        self.prev = prev
        self.data = data
        self.next = next

class NodeMgmt:
    def __init__(self, data):
        self.head = Node(data)
        self.tail = self.head

    def add(self, data):
        if self.head == None:
            self.head = Node(data)
            self.tail = self.head
        else:
            node = self.head
            while node.next:
                node = node.next
            new = Node(data)
            node.next = new
            new.prev = node
            self.tail = new

    def desc(self):
        node = self.head
        while node:
            print(node.data)
            node = node.next

    def search_from_head(self, data):
        if self.head == None:
            return False

        node = self.head
        while node:
            if node.data == data:
                return node
            else:
                node = node.next
        return False

    def search_from_tail(self, data):
        if self.head == None:
            return False
        node = self.tail
        while node:
            if node.data == data:
                return node
            else:
                node = node.prev
        return False

    def insert_before(self, data, before_data):
        if self.head == None:
            self.head = Node(data)
            return True

        else:
            node = self.tail
            while node.data != before_data:
                node = node.prev
                if node == None:
                    return False

            new = Node(data)
            before_new = node.prev
            before_new.next = new
            new.prev = before_new
            new.next = node
            node.prev = new
            return True

    def insert_after(self, data, after_data):
        if self.head == None:
            self.head = Node(data)
            return True

        else:
            node = self.head
            while node.data != after_data:
                node = node.next
                if node == None:
                    return False

            new = Node(data)
            after_new = node.next
            after_new.prev = new
            new.prev = node
            new.next = after_new
            node.next = new
            return True

double_linkedlist = NodeMgmt("Estus Flask")
item_list = ["Ashen Estus Flask", "Estus Shard", "Undead Bone Shard", "Homeward Bone"]
for item in item_list:
    double_linkedlist.add(item)
double_linkedlist.desc()

Estus Flask
Ashen Estus Flask
Estus Shard
Undead Bone Shard
Homeward Bone

double_linkedlist.insert_before("Fading Soul", "Estus Shard")
double_linkedlist.desc()

Estus Flask
Ashen Estus Flask
Fading Soul
Estus Shard
Undead Bone Shard
Homeward Bone

double_linkedlist.insert_after("Soul of a Deserted Corpse", "Estus Shard")
double_linkedlist.desc()

Estus Flask
Ashen Estus Flask
Fading Soul
Estus Shard
Soul of a Deserted Corpse
Undead Bone Shard
Homeward Bone