leetcode刷题之广度遍历

leetcode刷题广度遍历

广度遍历的套路相对比较固定 也由模板可以用

level = 0
while queue 不空：
    size = queue.size()
    while (size --) {
        cur = queue.pop()
        for 节点 in cur的所有相邻节点：
            if 该节点有效且未被访问过：
                queue.push(该节点)
    }
    level ++;

其中level表示的是层数 size是每层的个数

二叉树层序遍历

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
         if(root==null)
            return new ArrayList<>();
        
        Queue<TreeNode> qu = new ArrayDeque<>();
       // LinkedList<TreeNode> qu = new LinkedList<>();
        qu.add(root);
       // int i =0;
        List<List<Integer>> li = new ArrayList<>();

        while(!qu.isEmpty())
        {
            int size = qu.size();//记录这一层节点的个数 方便下面循环
            ArrayList<Integer> tmp = new ArrayList<Integer>();
            // 创建一个临时的 节点数组用来存放 上一层下面的节点
            for(int i = 0;i<size;i++)
            {
                TreeNode tmpTree = qu.poll();
                tmp.add(tmpTree.val); //这个地方要存的是 tree中val 而不是tree本身
                if(tmpTree.left!=null){
                    qu.offer(tmpTree.left);
                }
                if(tmpTree.right!=null){
                    qu.offer(tmpTree.right);
                }
         
            }
            li.add(tmp);//添加这一层的结果
        }
        return li;
    }
}

腐烂的橘子
在给定的网格中，每个单元格可以有以下三个值之一：
值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。
返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1

下面是一个月之前我写的代码

class Solution {
    public int orangesRotting(int[][] grid) {
        Queue<local> queue = new ArrayDeque<>();
        
      
        int count=0; //记录新鲜橘子总数
        for(int i = 0;i<grid.length;i++){
            for(int j =0;j<grid[0].length;j++){
                if (grid[i][j]==1)
                    count++;
                if(grid[i][j]==2){
                queue.add(new local(i,j));
                 //System.out.println(j);
                }
                    
        }
        }
        int depth = 0; // 记录深度
        while(!queue.isEmpty()&&count !=0)
        {
           
            
            depth++;
            int qunum = queue.size();
            for(int i=0;i<qunum;i++)
            {
                local tmp = queue.poll();
                 System.out.println(tmp.x);
                System.out.println(tmp.y);
                
                //上
                if(tmp.x-1>=0&&grid[tmp.x-1][tmp.y]!=0&&grid[tmp.x-1][tmp.y]!=2){
                    queue.add(new local(tmp.x-1,tmp.y));
                    grid[tmp.x-1][tmp.y] =2;
                    count--;
                }
                //下
                if(tmp.x+1<grid.length&&grid[tmp.x+1][tmp.y]!=0&&grid[tmp.x+1][tmp.y]!=2)
                {   queue.add(new local(tmp.x+1,tmp.y));
                 grid[tmp.x+1][tmp.y]=2;
                 count--;
                }
                //左
                if(tmp.y-1>=0&&grid[tmp.x][tmp.y-1]!=0&&grid[tmp.x][tmp.y-1]!=2)
                {   queue.add(new local(tmp.x,tmp.y-1));
                 grid[tmp.x][tmp.y-1]=2;
                 count--;
                 System.out.println(count);
                }
                //右
                if(tmp.y+1<grid[0].length&&grid[tmp.x][tmp.y+1]!=0&&grid[tmp.x][tmp.y+1]!=2)
                {   queue.add(new local(tmp.x,tmp.y+1));
                    grid[tmp.x][tmp.y+1]=2;
                count--;
                }
            }
            System.out.print(count);
        }
        if(count==0)
            return depth;
        else
            return -1;
    }
}
class local{
    int x;
    int y;
    local(int x1,int y1){
        x= x1;
        y = y1;
    }
}

这是我这次写笔记写的代码 感觉退步了 呜呜呜

class Solution {
    public int orangesRotting(int[][] grid) {
                Deque qu = new ArrayDeque();
        int res = 0;
        int u=0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if(grid[i][j]!=2){
                    if(grid[i][j]==1)//为了解决[[1]]  或者[[0]]这种橘子问题
                        u++;
                }
                else{
                    qu.addFirst(new int[]{i,j});
                }
            }
        }
        if(qu.isEmpty()){
            if(u>0)
            return -1;
            else
            return 0;

        }
     //   else
     //       res++;
        int size = qu.size();
        while(!qu.isEmpty())
        {
            int tmpnum =0;
            for (int i = 0; i < size; i++) {

                int[] tmp = (int[]) qu.pollLast();
                //不越界的新鲜感染的橘子
                if(tmp[0]-1>=0&&grid[tmp[0]-1][tmp[1]]==1){ 
                    qu.addFirst(new int[]{tmp[0]-1,tmp[1]});
                    grid[tmp[0]-1][tmp[1]]=2;
                    tmpnum++;
                }
                if(tmp[0]+1<grid.length&&grid[tmp[0]+1][tmp[1]]==1)
                {
                    qu.addFirst(new int[]{tmp[0]+1,tmp[1]});
                    grid[tmp[0]+1][tmp[1]]=2;
                    tmpnum++;
                }
                if(tmp[1]+1<grid[0].length&&grid[tmp[0]][tmp[1]+1]==1)
                {
                    qu.addFirst(new int[]{tmp[0],tmp[1]+1});
                    grid[tmp[0]][tmp[1]+1]=2;
                    tmpnum++;
                }
                if(tmp[1]-1>=0&&grid[tmp[0]][tmp[1]-1]==1){
                    qu.addFirst(new int[]{tmp[0],tmp[1]-1});
                    grid[tmp[0]][tmp[1]-1]=2;
                    tmpnum++;
                }
            }
            size = tmpnum;
            if(size>0)
                res++;
        }
		// 在上面代码中巧妙的用了一个count   这次写就没有想到;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if(grid[i][j] == 1)
                    return -1;
            }
        }
        return res;

    }
}

二叉树的锯齿形层次遍历
给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
例如：
给定二叉树 [3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回锯齿形层次遍历如下：
[
[3],
[20,9],
[15,7]
]

这题不难层序遍历加上一个 双端队列 解决问题

被围绕的区域