파이썬 링크드 리스트 구현

링크드 리스트

• 연결 리스트라고도 한다.
• 배열은 순차적으로 연결된 공간에 데이터를 나열하는 데이터 구조
• 링크드 리스트는 떨어진 곳에 존재하는 데이터를 화살표로 연결해서 관리하는 데이터 구조
• 본래 C언어에서는 주요한 데이터 구조지만, 파이썬은 리스트 타입이 링크드 리스트의 기능을 모두 지원

배열은 미리 공간을 확보해야하지만, Linked list는 필요할 때마다 노드를 생성할 수 있다.

기본 구조

• 노드 : 데이터 저장 단위 (데이터 값, 포인터)로 구성
• 포인터 : 각 노드 안에서, 다음이나 이전의 노드와의 연결 정보를 가지고 있는 공간

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

하나의 노드에는 데이터, 포인터가 한 쌍으로 필요하다.

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

def add(data):
    node = head
    while node.next:    # 노드의 next가 없을 때 까지  
        node = node.next 
    node.next = Node(data)    

node1 = Node(1)
head = node1
for index in range(2, 10):
    add(index)

노드에 1을 생성한 후 이후, 이어서 2 ~ 9 까지 연결된 링크드 리스트 구현

node = head
while node.next:
    print(node.data)
    node = node.next
print(node.data) # 마지막 노드의 데이터 

링크드 리스트 출력

장단점

• 장점
  • 미리 데이터 공간을 할당하지 않아도 된다.
  • 배열은 미리 할당해야 한다.
• 단점
  • 연결을 위한 별도의 데이터 공간이 필요하므로 , 저장 공간 효율이 높지 않다.
  • 연결 정보를 찾는 시간이 필요하므로 접근 속도가 느리다.
  • 중간 데이터 삭제시, 앞 뒤 데이터 연결을 재구성 해야 한다.

복잡한 기능1 (중간에 데이터 추가)

node3 = Node(1.5)
node = head
search = True
while search:
    if node.data == 1:
        search = False
    else:
    node = node.next

node_next = node.next
node.next = node3  # 중간 데이터 삽입을 위해 포인터를 변경 
node3.next = node_next

중간에 데이터를 삽입하기 위해 node_next 새로운 변수를 생성하여 이전의 next 값을 넣어둔다.

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(0)
linkedlist1.desc()

for data in range(1, 10):
    linkedlist1.add(data)

0 이 들어가있는 상태에서 1~9까지 추가 데이터 삽입

복잡한 기능2 (중간에 데이터 삭제)

• head 삭제
• 마지막 노드 삭제
• 중간 노드 삭제 (앞의 주소가 다다음 주소를 가르키고 삭제 데이터의 next를 None으로 만든다.)

def delete(self, data):
    if self.head =='': # 노드가 없을 때
        print('해당 값을 가진 노드가 없습니다')
        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
            else:
                node = node.next 

다양한 링크드 리스트

• 더블 링크드 리스트
  • 이중 연결 리스트라고도 한다.
  • 장점 : 양방향으로 연결되어 있어서 노드 탐색이 양쪽 모두 가능

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

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

    del insert(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

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

더블 링크드 리스트 클래스 생성

double_linked_list = NodeMgmt(0)
for data in range(1,10):
    double_linked_list.insert(data)
double_linked_list.desc()

데이터 출력

특정 노드 앞에 데이터를 추가

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

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

    del insert(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

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

    del 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

특정 노드 검색을 위한 search_from_head, tail, insert_before 함수 추가

특정 노드 뒤에 데이터 추가

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 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.next = node
            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
            new.next = after_new
            new.prev = node
            node.next = new
            if new.next == None:
                self.tail = new
            return True

    def insert(self, data):
        if self.head == None:
            self.head = Node(data)
        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