[코딩 + 알고리즘 완주반] 12일차. 스택, 링크드 리스트

# 스택(Stack)

데이터를 제한적으로 접근할 수 있는 구조

 - 한쪽 끝에서만 자료를 넣거나 뺄 수 있는 구조

가장 나중에 쌓은 데이터를 가장 먼저 빼낼 수 있는 구조

LIFO(Last In First Out)

 

# 스택의 활용

컴퓨터 내부의 프로세스 구조의 함수 동작 방식

 

# 주요 기능

-push() : 데이터를 스택에 넣기

-pop() : 데이터를 스택에서 꺼내기

 

# 스택 구조

프로세스 실행 구조를 스택과 비교해서 이해

 

# 스택의 장단점

장점 : 

구조가 단순해서 구현이 쉽다

더이터 저장/읽기 속도 빠르다

 

단점 : 

-데이터 최대 개수를 미리 정해야한다.

저장공간의 낭비가 발생할 수 있음

 

# 리스트 변수로 스택 구현해보기

stack_list = list()

def push(data):
    stack_list.append(data)

def pop():
    data = stack_list[-1]
    del stack_list[-1]
    return data

 

# 링크드 리스트 ( 연결 리스트)

떨어진 곳에 존재하는 데이터를 화살표로 연결해서 관리하는 데이터 구조

노드 : 데이터 저장 단위 ( 데이터값, 포인터)

포인터 :  각 노드 안에서, 다음이나 이전의 노드와의 연결 정보를 가지고 있는 공간

 

# 파이썬 노드 구현

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

# 노드 연결

node1 = Node(1)
node2 = Node(2)
node1.next = node2
head = node1

# 데이터 추가하기

def add(data):
    node = head
    while node.next:
        node = node.next
    node.next = Node(data) 

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

# 링크드 리스트 장단점

장점 :  미리 공간을 할당하지 않아도 됨 

단점 : 연결을 위한 별도 데이터 공간 필요, 저장 공간 효율이 높지 않음 

          접근 속도가 느림

          중간 데이터 삭제시, 데이터의 연결을 재구성하는 부가적인 작업 필요

 

# 노드 중간에 추가

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

# 다양한 기능 구현

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

# 다양한 링크드 리스트 구조

# 더블 링크드 리스트(이중 연결 리스트)

양방향으로 연결되어 있어서 양쪽 탐색이 가능

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