二叉树的广度优先搜索，使用队列结构Java语言实现

import java.util.ArrayList;
import java.util.LinkedList;

/**
 * 二叉树的广度优先搜索，广度优先遍历
 */
public class BinaryTreeBFS {

    /**
     * 二叉树的广度优先搜索直接输出遍历结果，使用队列的先进先出特点实现
     * @param root
     */
    public static void binaryTreeBFS01(BinaryTree root){
        if(root == null){
            return;
        }
        LinkedList<BinaryTree> list = new LinkedList<>();
        list.add(root);

        while(!list.isEmpty()){
           BinaryTree node = list.poll();
            System.out.println(node.value);
           if(node.left != null){
               list.add(node.left);
           }
           if(node.right != null){
               list.add(node.right);
           }
        }
    }

    /**
     * 广度优先搜索按照每一层记录需要使用两个循环
     * @param root 二叉树
     */
    public static ArrayList<ArrayList<Integer>> binaryTreeBFS(BinaryTree root){
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        LinkedList<BinaryTree> list = new LinkedList<>();

        if(root == null){
            return result;
        }
        list.add(root);
        while(!list.isEmpty()){
            int len = list.size();
            ArrayList<Integer> listLevel = new ArrayList<>();
            for(int i = 0; i < len ; i ++){
                BinaryTree node = list.poll();
                //记录结果值
                listLevel.add(node.value);
//                System.out.println(node.value);
                if(node.left != null){
                    list.add(node.left);
                }
                if(node.right != null){
                    list.add(node.right);
                }
            }
            result.add(listLevel);
        }
        return result;
    }



    public static void main(String[] args){
        BinaryTree head  = new BinaryTree(1);
        BinaryTree left  = new BinaryTree(2);
        BinaryTree right  = new BinaryTree(3);
        BinaryTree left01  = new BinaryTree(4);
        BinaryTree right01  = new BinaryTree(5);
        BinaryTree left02  = new BinaryTree(6);
        BinaryTree right02  = new BinaryTree(7);
        head.left = left;
        head.right = right;
        left.left = left01;
        left.right = right01;
        right.left = left02;
        right.right = right02;
        binaryTreeBFS01(head);
        System.out.println(binaryTreeBFS(head).toString());

        //结果1234567
        // [[1], [2, 3], [4, 5, 6, 7]]

    }
}



//二叉树的类
class BinaryTree{
    int value;
    BinaryTree left;
    BinaryTree right;

    public BinaryTree(int value){
        left = null;
        right = null;
        this.value = value;
    }
}