Java中二叉树的广度优先搜索（BFS）实现指南

public class Node {
    int data;
    Node left;
    Node right;

    // 构造函数
    public Node(int data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }

    // 可以根据需要添加getter/setter方法
    public int getData() {
        return data;
    }

    public void setLeft(Node left) {
        this.left = left;
    }

    public void setRight(Node right) {
        this.right = right;
    }
}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class BinaryTreeBFS {

    // Node class definition (同上，为完整性再次列出)
    public static class Node {
        int data;
        Node left;
        Node right;

        public Node(int data) {
            this.data = data;
            this.left = null;
            this.right = null;
        }

        public int getData() {
            return data;
        }
    }

    /**
     * 对二叉树执行广度优先搜索（BFS）并返回遍历结果列表。
     *
     * @param root 二叉树的根节点。
     * @return 包含按BFS顺序遍历的所有节点数据的列表。
     */
    public static List<Integer> bfs(Node root) {
        // 使用LinkedList实现Queue接口
        Queue<Node> queue = new LinkedList<>();
        // 存储遍历结果
        List<Integer> result = new ArrayList<>();

        // 如果根节点为空，直接返回空列表
        if (root == null) {
            return result;
        }

        // 将根节点添加到队列中，开始遍历
        queue.add(root);

        // 当队列不为空时，持续进行遍历
        while (!queue.isEmpty()) {
            // 从队列头部取出节点（并移除）
            Node currentNode = queue.poll();
            // 将当前节点的数据添加到结果列表
            result.add(currentNode.getData());

            // 如果当前节点有左子节点，将其添加到队列尾部
            if (currentNode.left != null) {
                queue.add(currentNode.left);
            }
            // 如果当前节点有右子节点，将其添加到队列尾部
            if (currentNode.right != null) {
                queue.add(currentNode.right);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        // 构建示例二叉树
        //       1
        //      / \
        //     7   9
        //      \ / \
        //      8 2  3
        Node node1 = new Node(1);
        Node node7 = new Node(7);
        Node node9 = new Node(9);
        Node node8 = new Node(8);
        Node node2 = new Node(2);
        Node node3 = new Node(3);

        node1.left = node7;
        node1.right = node9;
        node7.right = node8;
        node9.left = node2;
        node9.right = node3;

        // 执行BFS并打印结果
        System.out.println("BFS 遍历结果:");
        List<Integer> bfsResult = bfs(node1);
        for (Integer data : bfsResult) {
            System.out.print(data + " "); // 预期输出: 1 7 9 8 2 3
        }
        System.out.println();
    }
}