腐烂的橘子 - （LeetCode）

一、概述

994. 腐烂的橘子 - 力扣（LeetCode），今天刷到这道题，开始按照自己实现的思路写了一次，通过了调试，但是提交的时候，来了一个大的数据，就没有通过测试，百思不得其解，看了网上的思路，使用了java的Queue队列对象来进行解题，平时都没什么机会使用Queue队列，这次认真学习了Queue队列对象，代码优化后节省了一般的代码很多，而且优化了解题的思路。

先学习下Queue队列对象。

二、队列学习

队列的概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。
队列具有先进先出的特点 FIFO(FirstIn First Out)
入队列：进行插入操作的一端称为队尾（Tail/Rear）
出队列：进行删除操作的一端称为队头（front）

队列的术语

队尾：插入元素的一段
队头：删除元素的一段
入队：向队列中插入新的元素，新的元素入队后就会成为新的队尾。
出队：从队列中删除元素，元素被删除（出队）后，它的下一个元素就会成为新的队头。

三、普通队列(Queue)

队列可以使用数组或链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

队列的方法

入队列：add()、offer()

相同：未超出容量，从队尾压入元素，返回压入的那个元素。
区别：在超出容量时，add()方法会对抛出异常，offer()返回false
出队列：remove()、poll()

相同：容量大于0的时候，删除并返回队头被删除的那个元素。
区别：在容量为0的时候，remove()会抛出异常，poll()返回null
获取队头元素(不删除)：element()、peek()

相同：容量大于0的时候，都返回队头元素。但是不删除。
区别：容量为0的时候，element()会抛出异常，peek()返回null。

方法的使用

代码示例

import java.util.LinkedList;
import java.util.Queue;
 
public class TestDemo {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.offer(2);
        System.out.println(queue.peek());
        System.out.println(queue.element());
        System.out.println(queue.poll());
        System.out.println(queue.remove());
    }
}
 
运行结果：
1
1
1
2

四、题目

在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：

• 值 0 代表空单元格；
• 值 1 代表新鲜橘子；
• 值 2 代表腐烂的橘子。

每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。

示例 1：

输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4

示例 2：

输入：grid = [[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。

示例 3：

输入：grid = [[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 10
• grid[i][j] 仅为 0、1 或 2

五、解题思路

1、创建时间变量来计时。

2、新鲜橘子计数,用于最后判断没被感染的橘子🍊。

3、创建Queue队列，用于存储坏的橘子🍊，循环先找出等于2坏的橘子🍊，并加入队列。

4、判断Queue队列是否存在坏的橘子🍊，不存在则直接返回0。

4、循环Queue队列，对当前数组的上下左右方向判断等于1的新鲜橘子，把新鲜的橘子改为坏的橘子，并加入队列，用于Queue循环处理不断感染新鲜的橘子。

5、最后判断是否还存在新鲜的橘子🍊，存在则返回-1，否则返回分钟数。

六、代码

class Solution {
    public int orangesRotting(int[][] grid) {
        //创建时间变量来计时
        int minute = 0;
        //新鲜橘子计数,用于最后判断没被感染的橘子
        int good = 0;
        Queue<int[]> queue = new LinkedList<>();
        //先找出坏的橘子
        for (int x = 0; x < grid.length; x++) {
            for (int y = 0; y < grid[x].length; y++) {
                if (grid[x][y] == 2) {
                    queue.add(new int[]{x, y});
                    System.out.println("x:" + x + ",y:" + y);
                } else if (grid[x][y] == 1) {
                    good++;
                }
            }
        }
        if (queue.size() == 0) return good == 0 ? 0 : -1;
        //用来记录坐标，上下左右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};
        while (!queue.isEmpty()) {
            //开始一分钟的扩散
            minute++;
            int size = queue.size();
            for (int cou = 0; cou < size; cou++) { //取出所有的坏果
                //扩散处理
                int[] cell = queue.poll();
                int x = cell[0], y = cell[1];
                for (int i = 0; i < 4; i++) {
                    int nx = x + dx[i];
                    int ny = y + dy[i];
                    //边界判断，以及只能感染好果也就是 grid[newx][newy] 等于一的
                    if (nx >= 0 && nx < grid.length && ny >= 0 && ny < grid[0].length && grid[nx][ny] == 1) {
                        grid[nx][ny] = 2;               //将水果感染
                        good--;                             //好的水果数量减一
                        queue.add(new int[]{nx, ny});   //将新的坐标存入到集合，进行下一次感染（遍历）
                        System.out.println("nx:" + nx + ",ny:" + ny);
                    }
                }
            }
        }
        return good > 0 ? -1 : minute - 1;
    }
}

数据结构和算法是计算机科学中两个紧密相关的概念，它们之间的关系可以用以下几个点来阐述：

1. 定义与关系：
   • 数据结构：是计算机中存储、组织数据的方式。数据结构决定了数据如何被存储、访问和操作，以及数据之间的逻辑关系。常见的数据结构包括数组、链表、栈、队列、树、图等。
   • 算法：是一系列解决问题的步骤或指令。算法是对数据进行操作的过程或方法，它是为了解决特定问题而设计的。算法的效率（时间复杂度和空间复杂度）通常与所使用的数据结构密切相关。
2. 相互依赖：
   • 数据结构的选择直接影响算法的效率。例如，使用链表实现插入和删除操作通常比使用数组更高效，因为链表不需要移动其他元素。同样，树和图等复杂数据结构可以支持更高效的搜索和遍历算法。
   • 算法的设计也需要考虑数据结构的特性。例如，排序算法的选择可能会根据输入数据的特性（如是否已部分排序、是否包含重复元素等）而有所不同。
3. 优化与改进：
   • 优化数据结构可以改进算法的性能。例如，通过使用哈希表（一种特殊类型的数组）可以显著减少查找操作的时间复杂度。
   • 改进算法也可以使数据结构得到更有效的利用。例如，通过优化搜索算法，可以更快地遍历和查询树或图等复杂数据结构。
4. 实际应用：
   • 在实际软件开发中，数据结构和算法的选择对于程序的性能至关重要。例如，在处理大量数据时，选择合适的数据结构和算法可以显著提高程序的执行效率。
   • 许多现代软件系统和应用程序都依赖于复杂的数据结构和算法来实现其核心功能。例如，搜索引擎使用倒排索引和排名算法来返回最相关的搜索结果；图形处理软件使用图论算法来分析和操作图像；操作系统使用数据结构来管理内存和进程等。

综上所述，数据结构和算法是相互依存、相互影响的两个概念。在设计和实现高效、稳定的软件系统时，需要充分考虑数据结构和算法的选择和优化。