1. 트리

트리는 그림으로 보는 것이 이해가 빠르다.

 

트리 예시

보시다시피 가장 위에서 시작해 마치 뒤집어놓은 나무처럼 뻗어나는 것이 트리 구조다.

 

가장 위를 루트, 특정 노드의 기준으로 자신과 연결된 위쪽 노드를 부모노드, 아래를 자식노드라고 한다.

아래로 내려갈 수록 레벨이 0에서 시작해 1씩 증가한다.

가장 끝에 위치하여 자식이 없는 노드를 리프노드라고 한다.

 

 

2. 이진트리

이진 트리란 자식이 2개 이하만 존재하는 트리를 이진트리라 한다.

 

포화 이진 트리

이 중 리프를 제외한 모든 노드가 자식이 2개씩 존재할 경우, 포화 이진트리라고 한다.

노드의 번호는 최상단이 1로 시작해 왼쪽부터 순차적으로, 위 사진의 오른쪽 처럼 번호를 부여한다.

 

일반이진트리

일반 이진트리는 위 사진의 6번 처럼 빈 공간이 있을 수도 있다.

 

 

3. 트리의 순회

트리내의 정보를 찾을 때는 트리를 순회해야 한다.

트리의 정보를 순회할 때는 전위순회(preorder), 중위순회(inorder), 후위순회(postorder) 방법이 있다.

위와 같은 트리가 있다고 가정해보자

전위 순회(preorder)를 하면 루트인 화사부터 시작해 루트기준으로 왼쪽부터 다 훑어보는 방법이다.

순서는 아래와 같다.

화사 -> 솔라 -> 휘인 -> 쯔위 -> 문별 -> 선미

 

중위 순회(inorder)는 트리를 기준으로 왼쪽부터 시작해서 오른쪽으로 차근차근 순회하는 방법이다.

순서는 아래와 같다.

휘인 -> 솔라 -> 쯔위 -> 화사 -> 선미 -> 문별

 

후위 순회(postorder)은 왼쪽 자식 끝부분부터 시작해 같은 래밸의 같은 부모를 둔 노드를 순회한 다음 그 부모를 순회하는 방법이다.

순서는 아래와 같다.

휘인 -> 쯔위 -> 솔라 -> 선미 -> 문별 -> 화사

 

 

4. 이진탐색

이진탐색은 이진 트리에서 가장 활용도가 높은 것으로 데이터 크기를 기준으로 일정 형태로 구성한다.

 

이진탐색 예시

이진 탐색은 탐색 시간을 크게 줄일 수 있는 장점이 있다.

예를 들어, 10억개의 데이터가 있고 여기서 하나의 데이터를 찾는다고 가정해보자

그럼 일단 5억번째 데이터를 확인하고 찾고자 하는 데이터와 크기를 비교한다.

5억번째 데이터보다 크기가 작다면 2억5천만번째 데이터를 확인한다.

역시 작다면 1억 2천5백만번째 데이터를 확인한다.

역시 작다면 6천2백5십만번째 데이터를 확인한다.

역시 작다면 3천125만번째 데이터를 확인한다.

이런식으로 계속 반으로 줄여나간다.

 

때문에 이진 탐색방법을 사용하면 10억개의 데이터 기준 약 30번의 탐색만으로도 찾아낼 수 있다.

참고로 1000경의 데이터가 있을 경우 약 63번의 탐색만으로도 찾아낼 수 있다.

 

5. 구현

5-1. 트리

위에 예시로 나온 이진트리를 구현해보자

class TreeNode: # 트리노드
    def __init__(self) -> None:
        self.left = None
        self.data = None
        self.right = None

우선 클래스를 만들어준다.

이 클래스는 노드 클래스로, 데이터, 왼쪽, 오른쪽의 데이터를 가진다.

 

node1 = TreeNode()
node1.data = '화사'

node2 = TreeNode()
node2.data = '솔라'
node1.left = node2

node3 = TreeNode()
node3.data = '문별'
node1.right = node3

node4 = TreeNode()
node4.data = '휘인'
node2.left = node4

node5 = TreeNode()
node5.data = '쯔위'
node2.right = node5

node6 = TreeNode()
node6.data = '선미'
node3.left = node6

이제 각 노드를 정의해주자

node1이 루트이며 그 밑으로는 각각의 노드가 어디의 노드인지를 나타낸다.

 

 

print('         ',node1.data)
print('    ┌──────┴──────┐    ')
print('  ',node1.left.data, '        ', node1.right.data)
print('┌───┴───┐     ┌───┴───┐')
print(node1.left.left.data, '', node1.left.right.data, ' ',
      node1.right.left.data, '')

자료구조가 완성되었다면 보기좋게 출력해보자

출력결과는 아래와 같다.

(주석처리하면 모양이 기울어져서 따로 작성)

          화사
    ┌──────┴──────┐    
   솔라          문별
┌───┴───┐     ┌───┴───┐
휘인  쯔위   선미

 

5-2. 트리 순회

선술한 전위순회, 중위순회, 후위순회를 해보자

트리는 바로 위에서 구현한 것을 사용한다.

def preorder(node):
    if node == None: return    
    print(node.data, end = ' -> ')
    preorder(node.left)
    preorder(node.right)
preorder(node1)

# 실행결과
# 화사 -> 솔라 -> 휘인 -> 쯔위 -> 문별 -> 선미 ->

재귀호출을 사용하면 쉽게 구현할 수 있다.

나머지 중위순회나 후위순회는 위 코드의 순서를 바꿔주는 형태로 구현해 줄 수 있다.

 

def inorder(node):
    if node == None: return
    inorder(node.left)     # 재귀호출(Recursive Call)
    print(node.data, end = ' -> ')
    inorder(node.right)     # 재귀호출(Recursive Call)
inorder(node1)

# 실행결과
# 휘인 -> 솔라 -> 쯔위 -> 화사 -> 선미 -> 문별 ->

중위 순회 코드

def postorder(node):
    if node == None: return
    postorder(node.left)
    postorder(node.right)
    print(node.data, end =' -> ')
postorder(node1)

# 실행 결과
# 휘인 -> 쯔위 -> 솔라 -> 선미 -> 문별 -> 화사 ->

후위순회 코드다.

 

5-3. 이진탐색

이번엔 새로운 트리를 만들고 이진탐색을 구현해보자

트리는 이렇게 구성한다.

루트에서 시작하여 주어진 값을 비교하여 왼쪽으로 갈지, 오른쪽으로 갈지를 정한다.

이 과정을 계속 반복하여, 원하는 값을 찾아나간다.

 

if __name__ == '__main__':
    search = input('찾을 걸그룹을 입력 > ')

    current = root
    while True:
        if search == current.data:
            print(search, '찾음 끝!')
            break
        elif search < current.data: # 왼쪽 노드로
            if current.left == None:
                print(search, '못찹음 끝!')
                break
            else:
                current = current.left
        else: # 오른쪽 노드로
            if current.right == None:
                print(search, '못찹음 끝!')
                break
            else:
                current = current.right

 

트리구현을 포함한 전체코드는 아래와 같다.

 

# 이진 탐색 트리
# 전역변수 선언
memory = []
root = None
nameAry = ['블랙핑크', '레드벨벳', '마마무', '에이핑크', '걸스데이', '트와이스']

class TreeNode:
    def __init__(self) -> None:
        self.left = None
        self.data = None
        self.right = None

if __name__ == '__main__':
    node = TreeNode()
    node.data = nameAry[0] # 블랙핑크
    root = node
    memory.append(node)

    for name in nameAry[1:]:
        node = TreeNode()
        node.data = name
        
        current = root
        
        while True:
            if name < current.data: # 부모노드 왼쪽으로
                if current.left == None:
                    current.left = node
                    break
                current = current.left
            else: # 부모노드 오른쪽
                if current.right == None:
                    current.right = node
                    break
                current = current.right

        memory.append(current)
    print('이진 탐색 트리 구성 완료')
    print('               ',root.data)
    print('         ┌──────────┴──────────┐    ')
    print('    ',root.left.data, '            ', root.right.data)
    print('   ┌─────┴─────┐         ┌─────┴─────┐')
    print(root.left.left.data, '  ', root.left.right.data, ' ',
        root.right.right.data, '')
    
    #print(root.left.left.left.data)

    search = input('찾을 걸그룹을 입력 > ')

    current = root
    while True:
        if search == current.data:
            print(search, '찾음 끝!')
            break
        elif search < current.data: # 왼쪽 노드로
            if current.left == None:
                print(search, '못찹음 끝!')
                break
            else:
                current = current.left
        else: # 오른쪽 노드로
            if current.right == None:
                print(search, '못찹음 끝!')
                break
            else:
                current = current.right

 

 

1. 큐

스택이 데이터의 출입구가 하나라면 큐는 출구와 입구가 따로 있는 자료구조라고 생각할 수 있다.

선입선출 (First In First Out; FIFO)의 자료구조로 Queue라고도 한다.

큐의 예시

여기서

데이터를 삽입하는 것을 enQueue

데이터를 추출하는 것을 deQueue

데이터의 첫 번째 부분(출구 앞)을 front

데이터의 마지막 부분(입구 앞)을 rear

라고 한다.



 

1-1 구현

큐를 구현해 보자

큐는 보통 배열을 통해서 구현하는데 이러면 Enqueue와 Dequeue를 할 때마다 계속 데이터가 앞으로 밀려나는

문제가 생기는 점을 잘 고려해야 한다.

SIZE = 0
queue = []
front = rear = -1

먼저, 전역변수를 만든다.

 

큐에는 큐가 가득 찬 경우, 완전히 빈 경우, 데이터를 넣는 경우, 데이터를 빼는 경우가 있을 수 있다.

이것들을 전부 함수로 만들어주자

 

# Queue Full 체크
def isQueueFull():
    global SIZE, queue, front, rear
    if(rear != SIZE -1):
        return False
    elif(rear == SIZE -1)and (front == -1):
        return True
    else:
    	# deQueue를 하고나서 빈자리를 채운다.
        for i in range(front + 1 , SIZE):
            queue[i - 1] = queue[i]
            queue[i] = None
        front -= 1
        rear -= 1 # 1씩 감소시킨다.
        return False

큐가 가득 찼을 때를 위한 코드

 

 

 

# Queue Empty 체크
def isQueueEmpty():
    global SIZE, queue, front, rear
    if(front == rear):
        return True
    else:
        return False

큐가 완전히 비었을 때를 위한 코드

front와 rear의 값이 같다면 빈 것으로 판정한다.

 

def enQueue(data): # Queue 데이터 추가
    global SIZE, queue, front, rear
    if isQueueFull():
        print('=======================')
        print('!!!ERROR: Queue is Full')
        print('=======================')
    else:
        rear += 1
        queue[rear] = data

큐에 데이터를 추가하는 코드

 

 

def deQueue(): # Queue 데이터 추출
    global SIZE, queue, front, rear
    if isQueueEmpty():
        print('========================')
        print('!!!ERROR: Queue is Empty')
        print('========================')
        return None
    else:
        front += 1
        data = queue[front]
        queue[front] = None
        
        # deQueue를 한뒤 빈자리를 채운다.
        for i in range(front + 1, SIZE):
        	queue[i-1] = queue[i]
            queue[i] = None
        front -= 1
        rear -= 1 # 1씩 감소
        
        return data

데이터를 추출하는 deQueue 코드

이전에 작성한 큐가 비었는지에 대한 여부를 확인하는 함수를 먼저 사용한다.

 

 

def peek(): # Queue front+1 위치값 확인
    global SIZE, queue, front, rear
    if isQueueEmpty():
        print('========================')
        print('!!!ERROR: Queue is Empty')
        print('========================')
        return None
    else: 
        return queue[front+1]

queue의 가장 앞부분의 값을 확인하는 코드

 

 

여기까지 큐의 기능을 구현했고 이제 메인 엔트리 코드를 작성하자

 

if __name__ == '__main__':
    SIZE = int(input('큐 사이즈 입력 > '))
    queue = [None for _ in range(SIZE)]

    while True:
        select = input('삽입(I)/추출(E)/확인(V)/종료(X) >> ')
        if select.lower() == 'x':
            break
        elif select.lower() == 'i':
            data = input('입력데이터 >> ')
            enQueue(data)
            print(f'큐 상태 : {queue}')
        elif select.lower() == 'e':
            data = deQueue()
            print(f'추출 데이터 : {data}')
            print(f'큐 상태 : {queue}')
        elif select.lower() == 'v':
            data = peek()
            print(f'확인 데이터 : {data}')
            print(f'큐 상태 : {queue}')
        else:
            continue
    
    print('큐 프로그램 종료')

실행하면 먼저 '삽입(I)/추출(E)/확인(V)/종료(X) >> ' 문자열이 출력되고 어떤 값을 입력받았는냐에 따라 각자 다른 함수를

사용한다.

정해진 값이 아닌 다른 값을 입력받으면 무시하고 다시 입력받도록 구성했다.

 

 

1. 스택

스택이란 주로 실행취소 기능을 사용할 때 자주 사용하는 자료구조로

가장 마지막에 입력된 값이 가장 먼저 출력되는 형태의 자료구조다.

 

스택 이미지

여기서 새로운 데이터를 넣는 것을 push

최상단에 어떤 데이터가 있는지 확인하는 것을 peek

데이터를 꺼내는 것을 pop

이라고 한다.

1-1. 구현

스택을 구현해보자

 

SIZE = 10
stack = [None for _ in range(SIZE)]
top = -1 # 초기값 바닥

stack

# 출력결과
# [None, None, None, None, None, None, None, None, None, None]

10칸 짜리 스택을 만들었다. SIZE 변수 값에 따라 칸이 결정되고 굳이 10개일 필요는 없다.

 

top += 1
stack[top] = '커피'
top += 1
stack[top] = '녹차'
top += 1
stack[top] = '꿀물'
stack

# 실행결과
# ['커피', '녹차', '꿀물', None, None]

Push를 통해 자료를 넣은 모습, 그러나 단순 배열처럼 보인다.

이해를 위해 for문을 사용하여 출력해보자

print('--스택상태--')
for i in range(len(stack)-1, -1, -1):
    print(stack[i])
print('-----------')

# 실행 결과
# --스택상태--
# None
# None
# 꿀물
# 녹차
# 커피
# -----------

이제 가장 먼저 들어간 커피가 최하단에 위치한 걸 볼 수 있다.

 

data = stack[top]
stack[top] = None
top -= 1
print(f'pop -> {data}')
print('--스택상태--')
for i in range(len(stack)-1, -1, -1):
    print(stack[i])
    
# pop -> 꿀물
# --스택상태--
# None
# None
# None
# 녹차
# 커피

pop을 구현해본 모습

최상단에 위치한 데이터가 출력된 모습을 확인할 수 있다.

 

if top == -1:
    print('더 이상 데이터가 없습니다.')
else:
    pass

예외처리로 만약 데이터가 없을 경우를 대비한 부분

 

전체 코드는 아래와 같다.

# 스택 전체 구현
# global 변수
SIZE = 0
stack = []
top = -1

# 스택이 꽉 찼는지 여부 확인
def isStackFull():
    global SIZE, stack, top # 전역변수를 그대로 함수에서도 쓸래!
    if(top >= SIZE -1):
        return True
    else:
        return False
    
# 스택이 비어있는지 여부 확인
def isStackEmpty():
    global SIZE, stack, top
    if(top == -1):
        return True
    else:
        return False
    
# 스택에 데이터 추가
def push(data):
    global SIZE, stack, top
    if (isStackFull()):
        print('Stack is Full')
        return
    else:
        top +=1
        stack[top] = data

def pop():
    global SIZE, stack, top
    if(isStackEmpty()):
        print('Stack is Empty!')
        return None
    else:
        data = stack[top]
        stack[top] = None
        top -= 1
        return data

# top의 데이터 확인
def peek():
    global SIZE, stack, top
    if isStackEmpty():
        print('Stack is Empty')
        return None
    else:
        return stack[top]

# 메인 엔트리
if __name__ == '__main__':
    top = -1
    SIZE = int(input('스텍사이즈 입력 >> '))
    stack = [None for _ in range(SIZE)]

    while True:
        select = input('삽입(I)/추출(E)/확인(V)/종료(X) >> ')
        if select.lower() == 'x': # 입력값 소문자로 변경, 종료
            break
        elif select.lower() == 'i': # 삽입
            data = input('추가할 데이터 >> ')
            push(data)
            print(f'스택상태 : {stack}')
        elif select.lower() == 'e': # 추출
            data = pop()
            print(f'추출 데이터 : {data}')
            print(f'스택상태 : {stack}')
        elif select.lower() == 'v': # 확인
            data = peek()
            print(f'확인 데이터 : {data}')
            print(f'스택상태 : {stack}')
        else: 
            continue

    print('스택 프로그램 종료')

 

1. 단순 연결 리스트

연결 리스트의 종류

연결리스트의 종류로는 3가지가 있으나 원형 연결리스트와 이중 연결리스트는 제외하고

단순 연결 리스트만 다루어보자

 

연결리스트는 배열과 비슷해보이나 배열과는 다르게 중간에 데이터를 넣고 지우기가 굉장히 간편하다.

배열의 경우, 새로운 값을 넣거나 없앨 때, 인덱스 값이 다 조정이 되지만 연결리스트는 그저 두 데이터 사이에 값을 넣으므로 대상이 되는 두 자료만 바꾸어주면 되기 때문이다.

 

1-1. 구현

구현을 해보자 우선 클래스부터 만들어보자

class Node:
    def __init__(self) -> None:
        self.data = None # 현재 값
        self.link = None # 다음 노드 포인터

    def __str__(self) -> str:
        return f'{self.data}'

Node라는 클래스를 사용해서 연결 리스트의 기본을 만들었다.

node1 = Node()
node1.data = '다현'

print(node1)

node1을 만들고 새로운 값을 넣는다.

이러한 과정을 여러번 한다.

node2 = Node()
node2.data = '정연'
node1.link = node2
node3 = Node()
node3.data = '쯔위'
node2.link = node3
node4 = Node()
node4.data = '사나'
node3.link = node4
node5 = Node()
node5.data = '지효'
node4.link = node5

데이터를 넣어준 모습

print(node1.data, end = ' -> ')
print(node1.link.data, end = ' -> ')
print(node1.link.link.data, end = ' -> ')
print(node1.link.link.link.data, end = ' -> ')
print(node1.link.link.link.link.data)

# 실행 결과
# 다현 -> 정연 -> 쯔위 -> 사나 -> 지효

넣어준 데이터를 출력해보자

print문이 많이 사용되었지만 입력받는 데이터가 정상적으로 나오는 것을 볼 수 있다.

 

newNode = Node()
newNode.data = '재남'
newNode.link = node2.link # node3
node2.link = newNode

새로운 데이터를 넣어보자, 2번 노드('재남')에 새로운 노드를 삽입했다.

 

del(node3)

이번엔 3번노드('쯔위')를 삭제해 보았다.

 

print(node1.data, end = ' -> ')
print(node1.link.data, end = ' -> ')
print(node1.link.link.data, end = ' -> ')
print(node1.link.link.link.data, end = ' -> ')
print(node1.link.link.link.link.data)

# 실행결과
# 다현 -> 정연 -> 쯔위 -> 사나 -> 지효

이렇게 편집된 자료를 출력한 모습이다.

재남이 중간에 추가되고 쯔위가 삭제된 모습을 볼 수 있다.

 

1. 선형 리스트

 

데이터를 일정한 순서로 나열한 자료구조로 입력 순서대로 저장하는 데이터에 적당하다.

선형 자료구조 예시

만약 위 사진에서 중간에 자바스크립트를 3위와 4위 사이에 넣는다고 가정해보자

그럴 경우, 4위부터 마지막에 해당하는 자료들이 전부 한칸씩 뒤로 움직여야 한다.

반대로 없애는 경우도 마찬가지로 수정하고자 하는 부분부터 끝까지 그 순서를 하나씩 다 바꾸어 주어야하기 때문에

중간에 새로운 값을 넣거나 삭제할 때 매우 비효율적이다.

 

파이썬에서는 배열과 리스트를 구분하지 않지만 자료구조에서는 다르다.

 

2. 배열의 특징

- 인덱스를 사용해 값에 바로 접근
- 새로운 값을 삽입하거나 특정 인덱스 값을 삭제하기 어렵다.
    - 삽입 또는 삭제시, 인덱스를 다 뜯어고쳐야한다.
- 배열의 크기는 선언할 때 지정할 수 있으며, 한 번 선언하면 크기를 늘리거나 줄일 수 없다.
- 구조가 간단하므로 코딩 테스트에서 많이 사용한다.

 

 

3. 리스트의 특징

인덱스가 없어서 값에 접근하려면 Head 포인터부터 순서대로 접근해야 한다. 즉 값에 접근하는 속도가 느리다.
포인터로 연결되어 있으므로 중간 데이터 삽입 삭제가 빠르다.
선언할 때 크기를 별도로 지정하지 않아도 된다. 즉 리스트의 크기는 가변이며 크기가 변하기 쉬운 데이터를 다룰 때 적절하다.
포인터를 저장할 공간이 필요하므로 배열보다 구조가 복잡하다.

 

 

1. 자료구조

 

자료구조란 자료를 효율적으로 관리하는 방법이다.

자료구조가 없다면 창고에 물건이 아무런 질서도 없이 마구잡이로 쌓여있는 느낌이다.

반면 자료구조가 있다면 창고에 물건이 특정 규칙에 따라 정리가 되어 있는 느낌이다.

쓰레기를 버릴 때, 아무거나 버릴땐 일반 쓰레기에 버리고

종류별로 버릴 때는 분리수거를 하는 것과 비슷하다고 할 수 있다.

 

 

2. 자료구조의 종류

 

자료구조에는 단순자료구조, 선형자료구조, 비선형 자료구조, 파일 자료구조가 있다.

단순자료구조 선형자료구조 비선형 자료구조 파일 자료구조
정수 리스트 트리 순차 파일
실수 스택 그래프 색인 파일
문자   직접파일
문자열      

단순자료구조란 0, 100, -15 같은 정수, 0.1, 3.14 같은 실수, 'A', 'B', '가' 같은 문자, 'Hello', 'World' 같은 문자열이 있다.

 

선형자료구조란 데이터를 한 줄로 순차적으로 표현한 형태로 리스트, 스택, 큐가 있다.

 

선형 자료구조 예시

 

비선형자료구조란 하나의 데이터 뒤에 여러 개가 있는 형태로 트리와 그래프가 있다.

 

비선형 자료구조 예시

 

파일 자료구조는 파일 내용이 디스크에 저장되는 방식에 따라 순차 파일과 직접파일로 구분한다.

순차파일은 내용을 순서에 따라 연속해서 저장하는 것으로 구조가 간단하기에 저장되는 공간 효율이 높지만

중간에 뭔가 넣거나 없앨 때는 시간이 오래걸린다.

 

순차파일 예시

 

직접 파일은 파일 내용을 임의로 물리적 위치에 기록하는 방식으로 직접 접근 방식이라고 한다.

직접 접근 방식 예시

 

 

색인 순차 파일은 순차파일과 직접파일이 결합된 형태다.

 

 

+ Recent posts