Al nowcoder NC30 le falta el primer número entero positivo

Tabla de contenido

Tema Descripción:

Dada una matriz de números enteros sin elementos repetidos, busque el entero positivo más pequeño que no aparece en ella.

Avanzado : complejidad espacial O (1), complejidad temporal O (n)

Ejemplo 1

Entrada: [1,0,2]

Valor de retorno: 3

Ejemplo 2

Entrada: [-2,3,4,1,5]

Valor de retorno: 2

Ejemplo 3

Entrada: [4,5,6,8,9]

Valor de retorno: 1

analizar:

Después de leer la pregunta y los tres ejemplos dados, podemos sacar las siguientes conclusiones:

Los datos de la matriz dada son números enteros aleatorios y desordenados;
Los datos de la matriz dada contienen números negativos;
El valor de retorno no debe ser inferior a 1.

La complejidad espacial requerida por la pregunta es O (1) y la complejidad temporal es O (n), por lo que debemos intentar reducir la apertura del espacio tanto como sea posible.

Esta pregunta puede usar una tabla hash, pero la complejidad del espacio es O (n), por lo que este método debe usarse solo si realmente no puede pensar en una solución.

Entonces, en este momento podemos partir de la conclusión anterior : dado que la matriz está desordenada, primero podemos usar el método de la biblioteca para ordenarla.

    public int minNumberDisappeared (int[] nums) {
        Arrays.sort(nums);        
    }

Después de ordenar, nuestras ideas se abrieron de inmediato. Dado que puede haber números no mayores que 0 en la matriz, primero podemos usar un bucle para omitir esta parte :

    public int minNumberDisappeared (int[] nums) {
        int ret = 0; //返回值
        int len = nums.length; //数组长度
        Arrays.sort(nums);
        int i = 0; //记录数组遍历的位置

        while (i < len && nums[i] <= 0) {
            i++;
        }
    }

En este momento, solo hay números que no son menores que 0 en la matriz. Es muy simple hacer un juicio en este momento. Podemos juzgar directamente si hay un número entero entre los dos números y devolver el número entero si existe. . Si la matriz es [1,2,3,4] entonces devolvemos el último número más uno.

        while (i < len - 1) {
            if (nums[i] + 1 < nums[i+1]) {
                return nums[i] + 1;
            }
            i++;
        }
        ret = nums[len-1] + 1;
        return ret;

Finalmente llegamos al paso que es imprescindible cada vez que hacemos las preguntas: limitar el juicio de valor.

Luego juzgue la matriz al comienzo del código: si la matriz no existe, devuelva el entero positivo más pequeño 1 .

        if (nums == null || nums.length == 0) {
            return 1;
        }

Después del primer ciclo, se considera que si no hay 1 en la matriz, se devuelve 1 .

        if (nums[i] - 1 >= 1) {
            return 1;
        }

En este momento, si se ignora la complejidad de la función de la biblioteca, la complejidad que usamos en esta pregunta es: complejidad espacial O (1), complejidad temporal O (n).

Código completo:

import java.util.*;


public class Solution {

    public int minNumberDisappeared (int[] nums) {
        // write code here
        if (nums == null || nums.length == 0) {
            return 1;
        }
        int ret = 0;
        int len = nums.length;
        Arrays.sort(nums);
        int i = 0;

        while (i < len && nums[i] <= 0) {
            i++;
        }
        if (nums[i] - 1 >= 1) {
            return 1;
        }
        while (i < len - 1) {
            if (nums[i] + 1 < nums[i+1]) {
                return nums[i] + 1;
            }
            i++;
        }
        ret = nums[len-1] + 1;
        return ret;
    }
}