14-pu2rile

[pu2rile]

🔗 문제 링크

백준 - 이진 탐색 트리

✔️ 소요된 시간

1시간

✨ 수도 코드

문제 요약

아래 사진과 같이 주어진 트리를 참고하여 전위 순회(Preorder Traversal) 순서로 노드를 입력받아 이진 검색 트리(Binary Search Tree)를 구성한 후 후위 순회(Postorder Traversal) 순서로 노드를 출력

• 입력(전위 순회) : 50 30 24 5 28 45 98 52 60
• 출력(후위 순회) : 5 28 24 45 30 60 52 98 50

🔍 이진 트리의 순회

1. 전위 순회 : 루트 노드를 먼저 방문 후 왼쪽 자식, 오른쪽 자식을 방문하는 방식
2. 중위 순회 : 루트 노드의 왼쪽 자식 노드를 먼저 방문 후에 루트 노드를 중간에 방문하는 방식
3. 후위 순회 : 루트 노드의 왼쪽 자식, 오른쪽 자식을 방문 후 루트 노드를 마지막에 방문하는 방식

따라서, 문제의 입력(전위 순회)은

출력(후위 순회)은

이렇게 구할 수 있습니다.

알고리즘

1. 전위 순회 배열 입력
   • 전위 순회된 노드 값을 입력받아 배열 pre 에 저장
2. BST 생성
   • construct_bst 함수로 전위 순회 배열을 이용하여 재귀적으로 BST를 구성
3. 후위 순회
   • post_order 함수가 BST를 후위 순회하여 노드의 값을 출력

함수 설명

TreeNode* construct_bst(int pre[], int* preIndex, int key, int min, int max, int size)

구성

• 이 함수는 전위 순회 배열을 이용하여 재귀적으로 BST를 구성
• preIndex 는 배열에서 현재 처리 중인 요소를 가리킴
• key 는 현재 노드의 값이며, 배열의 pre[preIndex] 값
• min 과 max 는 현재 노드의 값이 가질 수 있는 범위를 지정
  • <limits.h> 라이브러리를 사용하여 메인에서 INT_MIN 과 INT_MAX 를 사용하여 범위 제한을 설정했음

동작

• 함수는 먼저 preIndex 가 배열의 크기(size )를 초과하는지 확인하여 배열의 끝에 도달했는지 확인
• then, 현재 key 가 min 과 max 범위 내에 있는지 확인
• if TRUE, 새로운 노드를 생성하고 preIndex 를 증가
• then, 왼쪽과 오른쪽 서브트리를 재귀적으로 구성

💻 최종 코드

확인

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

typedef struct TreeNode {
    int data;
    struct TreeNode *left, *right;
} TreeNode;

// 새로운 노드를 생성하는 함수
TreeNode* new_node(int key) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->data = key;
    node->left = node->right = NULL;
    return node;
}

// 전위 순회 배열을 이용해 BST를 생성하는 함수
TreeNode* construct_bst(int pre[], int* preIndex, int key, int min, int max, int size) {
    // 트리가 공백이면 NULL 반환
    if (*preIndex >= size)
        return NULL;

    TreeNode* root = NULL;

    // 현재 key가 min과 max 사이에 있을 때만 노드를 생성
    if (key > min && key < max) {
        root = new_node(key);
        *preIndex = *preIndex + 1;

        if (*preIndex < size) {
            // 왼쪽 서브트리를 구성
            root->left = construct_bst(pre, preIndex, pre[*preIndex], min, key, size);
        }
        if (*preIndex < size) {
            // 오른쪽 서브트리를 구성
            root->right = construct_bst(pre, preIndex, pre[*preIndex], key, max, size);
        }
    }
    return root;
}

// 후위 순회 함수
void post_order(TreeNode* root) {
    if (root) {
        post_order(root->left);  // 왼쪽 서브 트리 순회
        post_order(root->right); // 오른쪽 서브 트리 순회
        printf("%d\n", root->data); // 노드 방문
    }
}

int main(void) {
    int pre[10000]; // 최대 10000개의 노드를 입력받을 수 있도록 배열 크기를 지정
    int key;
    int size = 0;

    while (scanf("%d", &key) != EOF) {
        pre[size++] = key;
    }

    int preIndex = 0;
    if (size > 0) {
        TreeNode* root = construct_bst(pre, &preIndex, pre[0], INT_MIN, INT_MAX, size);
        post_order(root);
    }

    return 0;
}

📚 새롭게 알게된 내용

이진 검색 트리(BST)를 구성할 때 노드가 특정 범위 내에 있어야 트리가 올바른 형태를 유지할 수 있습니다. 이때, INT_MIN 과 INT_MAX 를 초기 범위로 사용하면 첫 번째 노드 삽입에 용이하다는 것을 알게 되었습니다.
→ 트리의 왼쪽 서브트리는 항상 현재 노드보다 작아야 하고 오른쪽 서브트리는 항상 현재 노드보다 커야 하는데, 최소값과 최대값을 사용하면 이러한 조건을 쉽게 확인할 수 있습니다.

[pu2rile]

free_tree(root); 를 추가해서 동적 할당된 트리 노드를 해제하여 메모리 누수를 방지할 수 있습니다... 까먹었어요 😅

[9kyo-hwang]

사실 요 문제의 원 의도는, preorder 순서로 주어진 노드 번호에서 left subtree, right subtree구간을 찾아내 이를 재귀적으로 방문하며 적절한 노드를 출력하는 거죠.

문제에서 주어진 트리인데, 이를 배열로 표현하면 다음과 같죠.

[50, 30, 24, 5, 28, 45, 98, 52, 60]

여기서 left subtree는 30, 24, 5, 28, 45, right subtree는 98, 52, 60이죠.
잘 보면 left는 root인 50보다 작은(작거나 같은) 요소들만 있고, right는 50보다 큰(크거나 같은) 것들만 있죠.

postorder는 left subtree -> right subtree -> root 순서로 출력하는 거죠? 즉
left subtree(30 ~ 45) 재귀 호출 -> right subtree(98 ~ 60) 재귀 호출 -> root(50) 출력
을 구현하면 됩니다.

#include <stdio.h>

int n = 0;
int preorder[10000];

void postorder(int begin, int end)
{
    if(begin >= end) return;
    
    int next = begin + 1;  // right subtree 시작 인덱스 찾기
    while(next < end && preorder[begin] >= preorder[next]) next++;

    postorder(begin + 1, next);  // left subtree 순회
    postorder(next, end);  // right subtree 순회
    printf("%d\n", preorder[begin]);  // root 출력
}

int main()
{
    while(scanf("%d", &preorder[n]) != EOF) n++;
    
    postorder(0, n);  // 시작 인덱스는 닫힌 구간, 끝 인덱스는 열린 구간입니다. 즉 [0, n)
    
    return 0;
}

---

TMI로, 이 문제는 22년/23년 권오흠 교수님 알고리즘 중간고사 시험문제 였습니다 :)