public void levelTraverse(TreeNode root){
    if(root == null){
        return;
    }
    //初始化队列
    Queue queue = new LinkedList();
    //把根节点加入队列
    queue.add(root);
    //开始遍历队列
    while(!queue.isEmpty()){
        TreeNode current = queue.poll();
        System.out.println(current.toString());
        //只要当前节点的左右节点不为空，那么我们就可以把其加入到队列的尾部，等待下一次遍历，我们continue这个while循环
        if(current.left != null){
            queue.add(current.left);
        }
        if(current.right != null){
            queue.add(current.right);
        }
    }
}

public class User{
    //这个friends是该用户的直接好友，也就是一度好友、
    private List<User> friends;
    private String name;
    //获取好友列表
    public List<User> getFriends(){
        return Collections.unmodifiableList(friends);
    }
    public String getUserName(){
        return name;
    }
}

public List<User> getXDegreeFriends(User user, int degree){
      List<User> results = new ArrayList<User>();
      Queue<User> queue = new LinkedList<User>();
      queue.add(user);
      //用于记录已经遍历过的User，因为A是B的好友，那么B也一定是A的好友，他们互相存在于对方的friends列表中。
      HashSet<User> visited = new HashSet<User>();
      //用一个counter记录当前的层数。
      int count = degree;
      //这里结束while循环的两个条件，一个是层数，一个是queue是否为空，因为万一该当前用户压根就没有那么多层的社交网络，比如他压根就没有朋友。
      while(count>=1 && !queue.isEmpty()){
          int queueSize = queue.size();
          for(int i = 0 ; i < queueSize; i++){
              User currentUser = queue.poll();
              //假如该用户已经遍历过，那么不做任何处理。
              if(!visited.contains(currentUser)){
                  results.add(currentUser);
                  queue.addAll(currentUser.getFriends();
                  visited.add(currentUser);
              }
          }
          count--;
      }
      return results;
}

public int getMinSteps(int[][] matrix) {
    int row = matrix.length;
    int col = matrix[0].length;
    //迷宫可以走四个方向，这个二维数组代表四个方向的x与y的偏移量
    int[][] direction = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
    HashSet<Integer> visited = new HashSet<>();
    Queue<Integer> queue = new LinkedList<>();
    //把起点加入到队列
    queue.add(0);
    int level = 0;
    while (!queue.isEmpty()) {
        //把该层的节点全部遍历
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            int current = queue.poll();
            if (!visited.contains(current)) {
                visited.add(current);
                //确定该节点的x与y坐标
                int currentX = current / col;
                int currentY = current % col;
                //假如该点是重点，那么直接返回level
                if (currentX == matrix.length - 1 && currentY == matrix[0].length - 1) {
                    return level;
                }
                //如果不是，那么我们分别把它的四个方向的节点都尝试加入到队列尾端，也就是下一层中
                for (int j = 0; j < direction.length; j++) {
                    int tempX = currentX + direction[j][0];
                    int tempY = currentX + direction[j][1];
                    //因为1代表墙壁，我们不能走，只能加数值为0的点
                    if (tempX > -1 && tempY > -1 && tempX <row&& tempY < col&& matrix[tempX][tempY] != 1) {
                        int code = tempX * col + tempY;
                        queue.add(code);
                    }
                }
            }
        }
        level++;
    }
    return -1;
}