본문 바로가기
Algorithm/자료구조 이론

Chapter 06. 링크드 리스트(Linked List)

by mean. 2020. 7. 20.
728x90
반응형

대표적인 데이터 구조: 링크드 리스트 (Linked List)

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

  • 연결 리스트라고도 함
  • 배열은 순차적으로 연결된 공간에 데이터를 나열하는 데이터 구조
  • 링크드 리스트는 떨어진 곳에 존재하는 데이터를 화살표로 연결해서 관리하는 데이터 구조
  • 본래 C언어에서는 주요한 데이터 구조이지만, 파이썬은 리스트 타입이 링크드 리스트의 기능을 모두 지원
  • 링크드 리스트 기본 구조와 용어
    • 노드(Node): 데이터 저장 단위 (데이터값, 포인터) 로 구성
    • 포인터(pointer): 각 노드 안에서, 다음이나 이전의 노드와의 연결 정보를 가지고 있는 공간

* 일반적인 링크드 리스트 형태
(출처: wikipedia, https://en.wikipedia.org/wiki/Linked\_list)

2. 간단한 링크드 리스트 예

Node 구현

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(1)  
node2 = Node(2)  
node1.next = node2 /Node(1)과 Node(2)를 연결
head = node1 /연결 리스트의 가장 앞부분을 또 다른 변수로 설정

링크드 리스트로 데이터 추가하기

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

def add(data):
    node = head
    while node.next: (현재 Node의 Next가 있다면)
        node = node.next (다음 Node로 이동, 마지막 Node의 도착한다면 종료)
    node.next = Node(data) (마지막 Node에 인자로 받는 Data를 연결)

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

링크드 리스트 데이터 출력하기(검색하기)

node = head
while node.next:
    print(node.data)
    node = node.next
print (node.data)

output:  
1  
2  
3  
4  
5  
6  
7  
8  
9

3. 링크드 리스트의 장단점 (전통적인 C언어에서의 배열과 링크드 리스트)

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

4. 링크드 리스트의 복잡한 기능1 (링크드 리스트 데이터 사이에 데이터를 추가)

  • 링크드 리스트는 유지 관리에 부가적인 구현이 필요함

(출처: wikipedia, https://en.wikipedia.org/wiki/Linked\_list)

node = head
while node.next:
    print(node.data)
    node = node.next
print (node.data)

output:
1
2
3
4
5
6
7
8
9

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 = head
while node.next:
    print(node.data)
    node = node.next
print (node.data)

output:
1
1.5
2
3
4
5
6
7
8
9

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

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()
output: 0

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

linkedlist1.desc()
output:
0
1
2
3
4
5
6
7
8
9

6. 링크드 리스트의 복잡한 기능2 (특정 노드를 삭제)

  • 다음 코드는 위의 코드에서 delete 메서드만 추가한 것이므로 해당 메서드만 확인하면 됨
  1. head 삭제
  2. 마지막 노드 삭제
  3. 중간 노드 삭제
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):
        // head가 없는 경우
        if self.head == '':
            print ("해당 값을 가진 노드가 없습니다.")
            return

        // head를 삭제하는 경우
        if self.head.data == data:
            temp = self.head //객체를 삭제하기 위해 옮겨둠.
            self.head = self.head.next //head의 주소를 다음 node로 옮김.
            del temp

        // 마지막 노드, 중간노드 삭제
        else:
            node = self.head
            while node.next:
                if node.next.data == data:
                    temp = node.next
                    node.next = node.next.next 
                    //삭제할 node의 next를 앞의 node의 next로 변경
                    del temp
                    return
                else:
                    node = node.next

테스트를 위해 1개 노드를 만들어 봄

linkedlist1 = NodeMgmt(0)
linkedlist1.desc()
output: 0

head 가 살아있음을 확인

linkedlist1.head
output: <__main__.Node at 0x1099fc6a0>

head 를 지워봄(위에서 언급한 경우의 수1)

linkedlist1.delete(0)

다음 코드 실행시 아무것도 안나온다는 것은 linkedlist1.head 가 정상적으로 삭제되었음을 의미

linkedlist1.head

output: none.

다시 하나의 노드를 만들어봄

linkedlist1 = NodeMgmt(0)
linkedlist1.desc()
output: 0

이번엔 여러 노드를 더 추가해봄

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

output:
0
1
2
3
4
5
6
7
8
9

노드 중에 한개를 삭제함 (위에서 언급한 경우의 수2)

// 중간 node를 삭제하는 경우
linkedlist1.delete(4)

특정 노드가 삭제되었음을 알 수 있음

linkedlist1.desc()

output:
0
1
2
3
5
6
7
8
9

// 마지막 node를 삭제하는 경우
linkedlist1.delete(9)
linkedlist1.desc()
output:
0
1
2
3
5
6
7
8

연습1: 위 코드에서 노드 데이터가 2인 노드 삭제해보기

node_mgmt.delete(2)
node_mgmt.desc()

output:
0
1
3
5
6
7
8

연습2: 위 코드에서 노드 데이터가 특정 숫자인 노드를 찾는 함수를 만들고, 테스트해보기

테스트: 임의로 1 ~ 9까지 데이터를 링크드 리스트에 넣어보고, 데이터 값이 4인 노드의 데이터 값 출력해보기

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

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
        //경우의 수1: self.head를 삭제해야할 경우 - self.head를 바꿔줘야 함
        if self.head.data == data:
            temp = self.head # self.head 
            //객체를 삭제하기 위해, 임시로 temp에 담아서 객체를 삭제했음
            self.head = self.head.next 
            // 만약 self.head 객체를 삭제하면, 이 코드가 실행이 안되기 때문!
            del temp
        else:
            node = self.head
            //경우의 수2: self.head가 아닌 노드를 삭제해야할 경우
            while node.next:
                if node.next.data == data:
                    temp = node.next
                    node.next = node.next.next       
                    del temp                         
                    pass                             
                else:
                    node = node.next

    def search_node(self, data):
        node = self.head
        while node:
            if node.data == data:
                return node
            else:
                node = node.next

테스트(test)

node_mgmt = NodeMgmt(0)
for data in range(1, 10):
    node_mgmt.add(data)

node = node_mgmt.search_node(4)
print (node.data)
output: 4

7. 다양한 링크드 리스트 구조

  • 더블 링크드 리스트(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):
        //초기값. head와 tail 모두 앞의 데이터를 가르킴.
        self.head = Node(data)
        self.tail = self.head

    def insert(self, data):
        if self.head == None: //head가 없는 경우.
            self.head = Node(data)
            self.tail = self.head
        else: //head가 있는 경우.
            node = self.head
            //node의 끝을 찾아가는 구문.
            while node.next:
                node = node.next
            //마지막에 새로운 node를 추가하고, 앞의 node와 insert되는 node를 이중 연결, 새로 생성된 node를 tail로 추가.
            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
//test
double_linked_list = NodeMgmt(0)
for data in range(1, 10):
    double_linked_list.insert(data)
double_linked_list.desc()

output:
0
1
2
3
4
5
6
7
8
9

연습3: 위 코드에서 노드 데이터가 특정 숫자인 노드 앞에 데이터를 추가하는 함수를 만들고, 테스트해보기

  • 더블 링크드 리스트의 tail 에서부터 뒤로 이동하며, 특정 숫자인 노드를 찾는 방식으로 함수를 구현하기
  • 테스트: 임의로 0 ~ 9까지 데이터를 링크드 리스트에 넣어보고, 데이터 값이 2인 노드 앞에 1.5 데이터 값을 가진 노드를 추가해보기
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(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

    //head 검색 함수
    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

    //tail 검색 함수
    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

    //특정 data 앞의 추가하는 함수
    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: //앞의 node가 없는 경우
                    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
double_linked_list = NodeMgmt(0)
for data in range(1, 10):
    double_linked_list.insert(data)
double_linked_list.desc()

output:
0
1
2
3
4
5
6
7
8
9
node_3 = double_linked_list.search_from_tail(3)
node_3.data
output: 3
double_linked_list.insert_before(1.5, 2)
double_linked_list.desc()

output:
0
1
1.5
2
3
4
5
6
7
8
9
node_3 = double_linked_list.search_from_tail(1.5)
node_3.data
output: 1.5

연습4: 위 코드에서 노드 데이터가 특정 숫자인 노드 뒤에 데이터를 추가하는 함수를 만들고, 테스트해보기

  • 더블 링크드 리스트의 head 에서부터 다음으로 이동하며, 특정 숫자인 노드를 찾는 방식으로 함수를 구현하기
  • 테스트: 임의로 0 ~ 9까지 데이터를 링크드 리스트에 넣어보고, 데이터 값이 1인 노드 다음에 1.7 데이터 값을 가진 노드를 추가해보기
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
node_mgmt = NodeMgmt(0)
for data in range(1, 10):
    node_mgmt.insert(data)

node_mgmt.desc()

node_mgmt.insert_after(1.5, 1)
node_mgmt.desc()

output:
0
1
2
3
4
5
6
7
8
9
0
1
1.5
2
3
4
5
6
7
8
9
728x90
반응형

'Algorithm > 자료구조 이론' 카테고리의 다른 글

Chapter 08. 해쉬 테이블(Hash Table)  (0) 2020.07.20
Chapter 07. 시간 복잡도  (0) 2020.07.20
Chapter 05. 스택(Stack)  (0) 2020.07.20
Chapter 04. 큐(Queue)  (0) 2020.07.17
Chapter 03. 배열  (0) 2020.07.14

관련글

티스토리툴바