Una [categoría de tema]

tabla de picadillo

Dos [dificultad de la pregunta]

dificultad

Tres [número de tema]

41. Falta el primer número positivo

Cuatro [descripción del título]

Dada una matriz de números enteros sin ordenar, busque el entero positivo más pequeño que no aparece en ella.
Implemente una solución que tenga una complejidad de tiempo O(n) y use solo un nivel constante de espacio adicional.

Cinco [ejemplos de temas]

Ejemplo 1:
- Entrada: números = [1,2,0]
- Salida: 3
Ejemplo 2:
- Entrada: números = [3,4,-1,1]
- Salida: 2
Ejemplo 3:
- Entrada: números = [7,8,9,11,12]
- Salida: 1

Seis [mensaje de tema]

$10^5$
$2^{31} <= números[i] <= 2^{31} - 1$

Siete [ideas para resolver problemas]

Realice "hashing en el lugar" en los elementos de la matriz, y el i-ésimo elemento se asigna a la posición i-1
De esta forma, para los elementos en 1-N, si no hay vacante, entonces el primer número positivo faltante debe ser N+1; si hay vacante, entonces el primer entero faltante debe estar en 1-N
Luego recorremos la matriz y devolvemos los elementos que no coinciden con el mapeo directamente

Ocho 【Frecuencia de tiempo】

Complejidad del tiempo: $O (n)$ , $n$ es la longitud de la matriz entrante
Complejidad espacial: $O (1)$

Nueve [implementación de código]

Versión del lenguaje Java

class Solution {
    
    
    public int firstMissingPositive(int[] nums) {
    
    
        int n = nums.length;
        for(int i = 0;i < n;i++){
    
    
            while(0 < nums[i] && nums[i] <= n && nums[nums[i] - 1] != nums[i]){
    
    
                swap(nums, nums[i] - 1, i);
            }
        }
        for(int i = 0;i < n;i++){
    
    
            if(nums[i] != i + 1){
    
    
                return i + 1;
            }
        }
        return n + 1;
    }

    public void swap(int[] nums, int index1, int index2){
    
    
        int temp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = temp;
    }
}

Versión en lenguaje C

void swap(int* nums, int index1, int index2)
{
    
    
    int temp = nums[index1];
    nums[index1] = nums[index2];
    nums[index2] = temp;
}

int firstMissingPositive(int* nums, int numsSize)
{
    
    
    int n = numsSize;
    for(int i = 0;i < n;i++)
    {
    
    
        while(0 < nums[i] && nums[i] <= n && nums[nums[i] - 1] != nums[i])
        {
    
    
            swap(nums, nums[i] - 1, i);
        }
    }
    for(int i = 0;i < n;i++)
    {
    
    
        if(i + 1 != nums[i])
        {
    
    
            return i + 1;
        }
    }
    return n + 1;
}

Versión en lenguaje Python

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        n = len(nums)
        for i in range(0, n):
            while 1 <= nums[i] and nums[i] <= n and nums[nums[i] - 1] != nums[i]:
                self.swap(nums, nums[i] - 1, i)
        for i in range(0, n):
            if nums[i] != i + 1:
                return i + 1
        return n + 1
    
    def swap(self, nums, index1, index2):
        temp = nums[index1]
        nums[index1] = nums[index2]
        nums[index2] = temp

Versión del lenguaje C++

class Solution {
    
    
public:
    int firstMissingPositive(vector<int>& nums) {
    
    
        int n = nums.size();
        for(int i = 0;i < n;i++){
    
    
            while(0 < nums[i] && nums[i] <= n && nums[nums[i] - 1] != nums[i]){
    
    
                swap(nums, nums[i] - 1, i);
            }
        }
        for(int i = 0;i < n;i++){
    
    
            if(nums[i] != i + 1){
    
    
                return i + 1;
            }
        }
        return n + 1;
    }

    void swap(vector<int>& nums, int index1, int index2){
    
    
        int temp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = temp;
    }
};