별의 공부 블로그 🧑🏻‍💻
728x90
728x170

이진 트리(Binary Tree)

이진 트리(Binary Tree)의 기본

이진 트리의 개념

  • 트리(Tree) 자료구조는 나무를 거꾸로 뒤집어 놓은 형태이다.
    • 트리의 맨 위를 뿌리(Root, 루트)라고 한다.
    • 루트를 레벨 0으로 두고 나뭇잎(Leaf, 리프)에 해당하는 아래로 내려올 수록 레벨이 1씩 증가한다.

 

  • 트리에서 각 위치를 노드(Node)라고 한다.
  • 각 노드는 선, 즉 에지(Edge)로 연결되어 있다.
  • 위 노드와 바로 아래 노드의 관계를 부모-자식 관계(Parent-Child Relationship)라고 한다.
  • 자식 노드의 개수를 차수(Degree)라고 한다.
  • 차수가 0인 노드를 리프(Leaf)라고 한다.

차수가 3인 트리

 

  • 트리의 차수차수가 가장 높은 노드를 기준으로 정한다.
  • 컴퓨터는 데이터를 0과 1로 표현하므로 트리 자료구조를 구현하려고 최대 차수가 2인 이진 트리(Binary Tree)를 사용한다.
    • 이진 트리는 모든 노드의 자식이 최대 2개인 트리이다.
    • 이진 트리는 모든 노드가 자식이 2개 이하로 구성되어 있다.

이진 트리의 예

 

  • 다음의 트리는 전형적인 이진 트리의 형태로, 높이가 3이고 루트 노드를 기준으로 왼쪽과 오른쪽 서브 트리 2개로 구성되어 있다.

 

이진 트리의 종류

  • 이진 트리는 포화 이진 트리(Full Binary Tree), 완전 이진 트리(Complete Binary Tree), 편향 이진 트리(Skewed Binary Tree) 3개로 나눈다.

 

① 포화 이진 트리(Full Binary Tree)

  • 모든 노드가 꽉 차 있는 상태의 트리
  • 노드 개수가 `2^{높이+1}-1` 공식으로 계산된다.
    • 예) 높이가 3인 포화 이진 트리는 노드 개수가 `2^{3+1}-1 = 15`개 이다.
  • 이진 트리에는 번호를 부여할 수 있는데, 루트 노드부터 왼쪽에서 오른쪽으로 번호를 부여한다.

노드 개수가 7개인 포화 이진 트리

 

② 완전 이진 트리(Complete Binary Tree)

  • 번호를 부여한 순서로 노드가 배치된 트리
  • 노드가 일부 비어 있어도 되지만, 끝 번호의 노드는 비어 있어야 한다.

 

  • 다음과 같은 트리는 완전 이진 트리가 아닌 그저 이진 트리일 뿐이다.

 

③ 편향 이진 트리(Skewed Binary Tree)

  • 모든 노드가 왼쪽이나 오른쪽으로 연결된 트리

왼쪽 편향 이진 트리(왼쪽)와 오른쪽 편향 이진 트리(오른쪽)

 

이진 트리의 노드 구조

  • 트리는 왼쪽 자식(Left Child) 오른쪽 자식(Right Child)으로 구성된다.
    • 그러므로 다음과 같이 왼쪽과 오른쪽 링크가 있는 이중 연결 리스트(Doubly Linked List) 구조로 만들 수 있다.

트리 노드 구현을 위한 이중 연결 리스트

 

  • 루트 노드부터 왼쪽과 오른쪽 링크를 가리키도록 구성하고, 가리킬 곳이 없는 링크는 비워 두면 된다.

완전 이진 트리와 편향 이진 트리의 노드 표현

 

이진 트리의 간단 구현

이진 트리의 생성

  • 다음과 같이 높이가 2이고 데이터가 6개인 완전 이진 트리를 구현해보자.

 

① 루트 노드를 생성한다.

 

② 두 번째 노드(솔라)를 생성하고 루트 노드의 왼쪽 노드로 지정한다.

 

③ 세 번째 노드(문별)를 생성하고 루트 노드의 오른쪽 노드로 지정한다.

 

④ 네 번째부터 여섯 번째까지 노드를 생성하고 부모 노드와 연결한다. 

 

class TreeNode() :
    def __init__ (self) :
        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

print(node1.data, end = ' ')
print()
print(node1.left.data,  node1.right.data, end = ' ')
print()
print(node1.left.left.data, node1.left.right.data, node1.right.left.data, end = ' ')
더보기
화사 
솔라 문별 
휘인 쯔위 선미

 

이진 트리의 순회

  • 순회(Traversal) : 이진 트리의 노드 전체를 한 번씩 방문하는 것
  • 자료구조로 데이터를 효율적으로 활용하는 대표적인 방법은 필요한 데이터를 효과적으로 검색하는 것이다.
    • 이를 위해 이진 트리에서는 노드 데이터를 처리하는 순서에 따라 전위 순회(Preorder Traversal), 중위 순회(Inorder Traversal), 후위 순회(Postorder Traversal)를 사용할 수 있다.

 

① 전위 순회(Preorder Traversal)

  • 노드의 데이터를 먼저 처리한다.
① 현재 노드 데이터 처리 (D)
② 왼쪽 서브 트리로 이동 (L)
③ 오른쪽 서브 트리로 이동 (R)

 

② 중위 순회(Inorder Traversal)

  • 노드의 데이터를 중간에 처리한다.
① 왼쪽 서브 트리로 이동 (L) 
② 현재 노드 데이터 처리 (D)
③ 오른쪽 서브 트리로 이동 (R)

 

③ 후위 순회(Postorder Traversal)

  • 노드의 데이터를 마지막에 처리한다.
 왼쪽 서브 트리로 이동 (L) 
오른쪽 서브 트리로 이동 (D) 
③ 현재 노드 데이터 처리 (P)

 

동작 과정 확인 : 전위 순회

더보기
  • 루트에서 시작하여 데이터 처리 → 왼쪽 서브 트리 → 오른쪽 서브 트리 순서로 순회한다.
ⓞ 전위 순회할 이진 트리

 

① 루트 노드(화사)의 데이터를 처리하고 왼쪽 서브 트리로 이동한다.

 

② 이동한 왼쪽 서브 트리의 솔라 데이터를 처리하고 다시 왼쪽 서브 트리로 이동한다.

 

③ 이동한 왼쪽 서브 트리의 휘인 데이터를 먼저 처리하고, 다시 왼쪽 서브 트리를 처리하려고 하나, 왼쪽 서브 트리가 없어 오른쪽 서브 트리를 처리하려고 한다. 그런데 오른쪽 서브 트리도 없으므로 휘인 노드는 처리가 완료되었다.

 

④ 현재 노드(휘인 노드)는 더 이상 처리할 것이 없으므로 앞 노드로 올라가서 처리하지 않았던 오른쪽 서브 트리로 내려간다.

 

⑤ 이동한 오른쪽 서브 트리의 쯔위 데이터를 먼저 처리하고, 왼쪽 서브 트리를 처리하려고 하나 왼쪽 서브 트리가 없어 오른쪽 서브 트리를 처리하려고 한다. 그런데 오른쪽 서브 트리도 없으므로 쯔위 노드는 처리가 완료되었다.

 

⑥ 현재 노드(쯔위 노드)는 더 이상 처리할 것이 없으므로 앞 노드(솔라 노드)로 올라간다. 앞 노드도 처리가 완료되었으므로 다시 앞 노드(화사 노드)로 올라가 오른쪽 서브 트리로 이동한다.

 

⑦ 이동한 오른쪽 서브 트리의 문별 데이터를 먼저 처리하고 다시 왼쪽 서브 트리로 이동한다.

 

⑧ 이동한 왼쪽 서브 트리의 선미 데이터를 먼저 처리하고, 다시 왼쪽 서브 트리를 처리하려고 하나 왼쪽 서브 트리가 없어 오른쪽 서브 트리를 처리하려고 한다. 그런데 오른쪽 서브 트리도 없으므로 선미 노드는 처리가 완료되었다. 그리고 트리의 모든 노드 순회가 완료되었다.

 

  • ①~⑧에서 출력된 데이터를 확인하면 화사, 솔라, 휘인, 쯔위, 문별, 선미 순이다.
    • 전위 순회인 현재 데이터 → 왼쪽 서브 트리 → 오른쪽 서브 트리 순서대로 출력된 것을 확인할 수 있다.

 

  • 좀 더 간단한 트리 순회
    • 좀더 직관적으로 다음과 같이 트리를 순회할 수 있다.
더보기
  • 전위 순회 : 루트 → 왼쪽 → 오른쪽

 

  • 중위 순회 : 왼쪽 루트 → 오른쪽

 

  • 후위 순회 : 왼쪽 → 오른쪽 루트

 

구현

  • 이진 트리의 순회를 구현하는 방식
    • 스택(Stack)을 이용하는 방식
    • 재귀 함수(Recursion Function)를 이용하는 방식
이진 트리의 순회 : 재귀 함수 사용
class TreeNode() :
    def __init__ (self) :
        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

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

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

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

print('전위 순회 : ', end = '')
preorder(node1)
print('끝')

print('중위 순회 : ', end = '')
inorder(node1)
print('끝')

print('후위 순회 : ', end = '')
postorder(node1)
print('끝')
더보기
전위 순회 : 화사->솔라->휘인->쯔위->문별->선미->끝
중위 순회 : 휘인->솔라->쯔위->화사->선미->문별->끝
후위 순회 : 휘인->쯔위->솔라->선미->문별->화사->끝

 

이진 탐색 트리(Binary Search Tree)의 일반 구현

이진 탐색 트리(Binary Search Tree)

  • 이진 트리 중 활용도가 높은 트리
  • 데이터 크기를 기준으로 일정 형태로 구성한다.
  • 루트의 값을 기준으로 왼쪽에는 루트의 값 보다 작은을 갖는 노드로 구성되어 있고, 오른쪽에는 루트의 값 보다을 갖는 노드로 구성되어 있다.
    • 같은 방법으로 루트의 왼쪽 서브 트리오른쪽 서브 트리도 왼쪽에는 작은 값으로 구성되어 있고, 오른쪽에는 큰 값으로 구성되어 있다.

 

  • 이진 탐색 트리의 특징
왼쪽 서브 트리는 루트 노드보다 모두 작은 값을 가진다.
오른쪽 서브 트리는 루트 노드보다 모두 큰 값을 가진다.
③ 각 서브 트리도 ①, ②의 특징을 갖는다.
④ 모든 노드 값은 중복되지 않는다. 즉, 중복된 값은 이진 탐색 트리에 저장할 수 없다.

 

① 이진 탐색 트리의 생성

  • 루트 노드만 root 변수로 사용하고, 나머지 노드는 별도의 변수 없이 무한대 메모리에 넣는 형태로 생성하면 된다.

그림에는 노드가 트리 구조로 가지런히 들어 있지만, 실제로는 노드의 위치나 순서는 상관 없이 서로 링크로만 연결된다.

 

  • 먼저 메모리를 준비하고 rootNone으로 초기화한다.
memory = []
root = None

 

  • 그리고 배열에 있는 데이터르 차례대로 이진 탐색 트리에 삽입한다.
nameAry = ['블랙핑크', '레드벨벳', '에이핑크', '걸스데이', '트와이스', '마마무']

 

  • 먼저 배열의 첫 번째 데이터를 최상위 노드로 지정한 후, 다음 과정을 거친다.
node = TreeNode()         # 노드 생성
node.data = nameAry[0]    # 데이터 입력
root = node               # 첫 번째 노드를 루트 노드로 지정
memory.append(node)       # 생성한 노드를 메모리에 저장

 

  • 다음 두 번째 이후 데이터를 삽입할 때는 이진 탐색 트리의 특징을 고려해야 한다.
    • 루트 노드보다 입력할 데이터가 작으면 왼쪽에 삽입하고, 크면 오른쪽에 삽입하도록 코드를 작성해야 한다.
name = '레드벨벳'             # 두 번째 데이터
node = TreeNode()           # 새 노드 생성
node.data = name            # 새 노드에 데이터 입력

current = root              # 현재 작업 노드를 루트 노드로 지정
if name < current.data :    # 입력할 값을 현재 작업 노드의 값과 비교
    current.left = node     # 작으면 새 노드를 왼쪽 링크로 연결
else :
    current.right = node    # 크면 새 노드를 오른쪽 링크로 연결
    
memory.append(node)         # 새 노드를 메모리에 저장

 

  • 이진 탐색 트리에서 데이터를 삽입하는 일반적인 형태는 다음과 같다.

name = 6                                  # 위치를 찾을 새 데이터
node = TreeNode()                         # 새 노드 생성
node.data = name

current = root                            # 루트부터 시작
while True :                              # 무한 반복
    if name < current.data :              # 1단계
        if current.left == None :         # 4단계
            current.left = node           # 4단계
            break
        current = current.left            # 2~3단계
    else :
        if current.right == None :        # 4단계
            current.right = node          # 4단계
            break
        current = current.right

 

구현 : 이진 탐색 트리에서의 삽입

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

memory = []
root = None
nameAry = ['블랙핑크', '레드벨벳', '마마무', '에이핑크',  '걸스데이', '트와이스' ]

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(node)

print("이진 탐색 트리 구성 완료!")
더보기
이진 탐색 트리 구성 완료!

 

② 이진 탐색 트리에서의 데이터 검색

  • 이진 탐색 트리에서 데이터를 검색할 때도 루트 노드부터 다음 과정을 진행한다.
if 현재 작업 노드의 데이터 == 찾을 데이터 :
    탐색 종료
elif 현재 작업 노드의 데이터 < 찾을 데이터 :
    왼쪽 서브 트리 탐색
else :
    오른쪽 서브 트리 탐색

 

데이터 검색 동작 과정

더보기
① 찾고자 하는 마마무를 루트 노드의 데이터와 비교한다. 마마무가 루트 노드의 데이터보다 작아 왼쪽으로 이동한다.

 

② 왼쪽 서브 트리에서도 동일하게 처리한다. 찾고자 하는 마마무가 왼쪽 서브 트리의 루트 노드보다 커 오른쪽으로 이동한다.

 

③ 오른쪽 서브 트리에서도 동일하게 처리한다. 그런데 여기에서는 마마무를 찾았으므로 종료한다.

 

구현 : 이진 탐색 트리에서의 검색 

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

memory = []
root = None
nameAry = ['블랙핑크', '레드벨벳', '마마무', '에이핑크',  '걸스데이', '트와이스' ]

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(node)

findName = '마마무'

current = root
while True :
    if findName == current.data:
        print(findName, '을(를) 찾음.')
        break
    elif findName < current.data :
        if current.left == None :
            print(findName, '이(가) 트리에 없음')
            break
        current = current.left
    else :
        if current.right == None :
            print(findName, '이(가) 트리에 없음')
            break
        current = current.right
더보기
마마무 을(를) 찾음.

 

③ 이진 탐색 트리에서 데이터 삭제

리프 노드(맨 아래쪽 노드)를 삭제하는 경우

  • 이진 탐색 트리에서 리프 노드의 삭제는 가장 간단한다.
  • 부모 노드의 링크를 None으로 변경하고, 현재 작업 노드를 삭제하면 된다.

 

  • 현재 노드가 부모 노드의 왼쪽 링크인지, 오른쪽 링크인지 구분하고자 코드 형태로 구현하면 다음과 같다.
if parent.left == current :    # 부모 노드 왼쪽 링크와 삭제할 노드가 같으면
    parent.left = None         # 부모 노드 왼쪽에 None 대입
else :                         # 부모 노드 오른쪽 링크와 삭제할 노드가 같으면
    parent.right = None        # 부모 노드 오른쪽에 None 대입

del(current)                   # 노드 삭제

 

자식 노드가 하나인 노드를 삭제하는 경우

  • 자식 노드가 하나인 노드를 삭제할 때는 삭제할 노드를 가리키는 부모 노드의 링크를 자식 노드로 먼저 변경한 후 해당 노드를 삭제해야 한다.

 

  • 그런데 코드를 구현할 때는 왼쪽 자식 노드가 있는 경우오른쪽 자식 노드가 있는 경우로 나누어 생각해야 한다.

 

왼쪽 자식 노드가 있는 경우
if parent.left == current :         # 부모 노드 왼쪽 링크와 삭제할 노드가 같으면
    parent.left = current.left      # 부모 노드의 왼쪽 링크에 왼쪽 자식 노드 대입
else :                              # 부모 노드 오른쪽 링크와 삭제할 노드가 같으면
    parent.right = current.left     # 부모 노드의 오른쪽 링크에 왼쪽 자식 노드 대입

del(current)                        # 노드 삭제

 

오른쪽 자식 노드가 있는 경우
if parent.left == current :          # 부모 노드 왼쪽 링크와 삭제할 노드가 같으면
    parent.left = current.right      # 부모 노드의 왼쪽 링크에 오른쪽 자식 노드 대입
else :                               # 부모 노드 오른쪽 링크와 삭제할 노드가 같으면
    parent.right = current.right     # 부모 노드의 오른쪽 링크에 오른쪽 자식 노드 대입

del(current)                         # 노드 삭제

 

 자식 노드가 둘 있는 노드를 삭제하는 경우

  • 자식 노드가 둘 있는 노드를 삭제할 때는 재귀를 사용해야 편리하다.
① 삭제할 노드의 왼쪽 서브 트리에서 키 값이 가장 큰 노드를 검색한다. (또는 삭제할 노드의 오른쪽 서브 트리에서 키 값이 가장 작은 노드를 검색한다.)
② 검색한 노드를 삭제할 노드의 위치로 옮긴다.
③ 옮긴 노드를 삭제한다. 삭제 시, 자식 노드의 개수에 따라 데이터가 조정된다.
옮긴 노드에 자식이 없을 경우 : 옮긴 노드의 부모는 자식으로 None을 가진다.
옮긴 노드에 자식이 1개 있을 경우 : 옮긴 노드의 부모는 그 자식으로 옮긴 노드의 자식을 가진다.

 


6 삭제 : 옮길 노드에 자식이 없는 경우
5 삭제 : 옮길 노드에 자식이 1개 있는 경우
8 삭제
7 삭제

 

구현 : 이진 탐색 트리에서의 삭제

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

memory = []
root = None
nameAry = ['블랙핑크', '레드벨벳', '마마무', '에이핑크',  '걸스데이', '트와이스' ]

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(node)

deleteName = '마마무' 

current = root
parent = None
while True:
    if deleteName == current.data :
        if current.left == None and current.right == None : 
            if parent.left == current :
                parent.left = None
            else :
                parent.right = None
            del(current)

        elif current.left != None and current.right == None : 
            if parent.left == current :
                parent.left = current.left
            else :
                parent.right = current.left
            del(current)

        elif current.left == None and current.right != None : 
            if parent.left == current:
                parent.left = current.right
            else:
                parent.right = current.right
            del(current)

        print(deleteName, '이(가) 삭제됨.')
        break
    elif deleteName < current.data :
        if current.left == None :
            print(deleteName, '이(가) 트리에 없음')
            break
        parent = current
        current = current.left
    else:
        if current.right == None :
            print(deleteName, '이(가) 트리에 없음')
            break
        parent = current
        current = current.right
더보기
마마무 이(가) 삭제됨.

 

 

이진 탐색 트리의 응용

  • 이진 탐색 트리는 데이터를 보관하고 검색할 때 효율적이다.
  • 순서대로 보관하기 때문에 검색에서도 효율성이 크다.
  • 이러한 이진 탐색 트리의 특징을 이용하여 도서관 책 목록의 보관과 검색을 위한 프로그램을 만들 수 있다.

 

프로그램 구현 : 도서관 책 목록의 보관과 검색
import random

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

memory = []
rootBook, rootAuth = None, None
bookAry = [ ['어린왕자', '쌩떽쥐베리'],['이방인', '까뮈'], ['부활', '톨스토이'],
           ['신곡', '단테'], ['돈키호테', '세브반테스'], ['동물농장', '조지오웰'],
           ['데미안','헤르만헤세'], ['파우스트', '괴테'], ['대지', '펄벅'] ]
random.shuffle(bookAry)

### 책 이름 트리 ###
node = TreeNode()
node.data = bookAry[0][0]
rootBook = node
memory.append(node)

for book in bookAry[1:] :
    name = book[0]
    node = TreeNode()
    node.data = name

    current = rootBook
    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(node)

print("책 이름 트리 구성 완료!")

### 작가 이름 트리 ###
node = TreeNode()
node.data = bookAry[0][1]
rootAuth = node
memory.append(node)

for book in bookAry[1:] :
    name = book[1]
    node = TreeNode()
    node.data = name

    current = rootAuth
    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(node)

print("작가 이름 트리 구성 완료!")

## 책 이름 및 작가 이름 검색 ##
bookOrAuth = int(input('책검색(1), 작가검색(2)-->'))
findName = input('검색할 책 또는 작가-->')

if bookOrAuth == 1 :
    root = rootBook
else :
    root = rootAuth

current = root
while True:
    if findName == current.data :
        print(findName, '을(를) 찾음.')
        findYN = True
        break
    elif findName < current.data :
        if current.left == None :
            print(findName, '이(가) 목록에 없음')
            break
        current = current.left
    else:
        if current.right == None :
            print(findName, '이(가) 목록에 없음')
            break
        current = current.right

root = None
nameAry = ['블랙핑크', '레드벨벳', '마마무', '에이핑크',  '걸스데이', '트와이스' ]

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(node)

deleteName = '마마무' 

current = root
parent = None
while True:
    if deleteName == current.data :
		
        if current.left == None and current.right == None : 
            if parent.left == current :
                parent.left = None
            else :
                parent.right = None
            del(current)

        elif current.left != None and current.right == None : 
            if parent.left == current :
                parent.left = current.left
            else :
                parent.right = current.left
            del(current)

        elif current.left == None and current.right != None : 
            if parent.left == current:
                parent.left = current.right
            else:
                parent.right = current.right
            del(current)

        print(deleteName, '이(가) 삭제됨.')
        break
    elif deleteName < current.data :
        if current.left == None :
            print(deleteName, '이(가) 트리에 없음')
            break
        parent = current
        current = current.left
    else:
        if current.right == None :
            print(deleteName, '이(가) 트리에 없음')
            break
        parent = current
        current = current.right
더보기
책 이름 트리 구성 완료!
작가 이름 트리 구성 완료!
책검색(1), 작가검색(2)-->1
검색할 책 또는 작가-->대지
대지 을(를) 찾음.

 

 

 

 

728x90
그리드형(광고전용)
⚠️AdBlock이 감지되었습니다. 원할한 페이지 표시를 위해 AdBlock을 꺼주세요.⚠️
starrykss
starrykss
별의 공부 블로그 🧑🏻‍💻


📖 Contents 📖