다음과 같은 이진 트리가 있다고 가정하자:

//                1
//           /        \
//         2            3
//       /   \        /   \
//      4     5      6     7

이 트리를 레벨 단위로 출력해야 하며, 출력 형식은 다음과 같아야 한다:

1
2 3
4 5 6 7

이 문제는 너비 우선 탐색(BFS)을 활용하여 해결할 수 있다. 핵심 아이디어는 큐를 사용해 노드를 순차적으로 처리하면서 각 레벨의 노드 수를 추적하는 것이다.

구체적인 로직은 다음과 같다:

1. 큐에 현재 레벨의 노드들을 삽입하고, 해당 레벨의 노드 개수를 카운트한다.
2. 큐에서 노드를 하나씩 꺼내어 값을 출력한 후, 자식 노드가 존재하면 다음 레벨을 위해 큐에 추가한다.
3. 현재 레벨의 모든 노드를 출력한 후 줄바꿈을 수행하고, 다음 레벨의 노드 수로 전환한다.

이를 구현한 Java 코드는 아래와 같다:

import java.util.LinkedList;
import java.util.Queue;

class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.value = val;
        this.left = null;
        this.right = null;
    }
}

public class LevelOrderTreePrint {

    public static void printByLevel(TreeNode root) {
        if (root == null) return;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int currentLevelCount = 1;
        int nextLevelCount = 0;

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            System.out.print(node.value + " ");
            currentLevelCount--;

            if (node.left != null) {
                queue.offer(node.left);
                nextLevelCount++;
            }

            if (node.right != null) {
                queue.offer(node.right);
                nextLevelCount++;
            }

            if (currentLevelCount == 0) {
                System.out.println();
                currentLevelCount = nextLevelCount;
                nextLevelCount = 0;
            }
        }
    }

    public static void main(String[] args) {
        TreeNode n1 = new TreeNode(1);
        TreeNode n2 = new TreeNode(2);
        TreeNode n3 = new TreeNode(3);
        TreeNode n4 = new TreeNode(4);
        TreeNode n5 = new TreeNode(5);
        TreeNode n6 = new TreeNode(6);
        TreeNode n7 = new TreeNode(7);

        n1.left = n2;
        n1.right = n3;
        n2.left = n4;
        n2.right = n5;
        n3.left = n6;
        n3.right = n7;

        printByLevel(n1);
    }
}

이 방식은 시간 복잡도가 O(n)이며, 모든 노드를 정확히 한 번씩 방문하기 때문에 효율적이다. 공간 복잡도는 최악의 경우 큐에 가장 많은 노드가 저장되는 마지막 레벨을 기준으로 O(w)가 된다. 여기서 w는 트리의 최대 너비이다.