Algoritmo: O (1) tiempo para insertar, eliminar y obtener elementos aleatorios --- tabla hash + matriz dinámica

1. Tema:

Clase de implementación RandomizedSet:

• RandomizedSet()inicializar RandomizedSetobjeto
• bool insert(int val)Cuando el elemento valno existe, inserte el elemento en la colección y devuelva true; de lo contrario, devuelva false.
• bool remove(int val)Si el elemento valexiste, elimine el artículo de la colección y devuélvalo true; de lo contrario, devuélvalo false.
• int getRandom()Devuelve un elemento aleatorio de una colección existente (el caso de prueba garantiza que al menos un elemento esté presente en la colección cuando se llama a este método). Cada elemento debe tener la misma probabilidad de ser devuelto.

Debe implementar todas las funciones de la clase y satisfacer la complejidad de tiempo promedioO(1) de cada función .

2. Funciones de análisis:

• Requisitos de la pregunta: la complejidad temporal de insertar, eliminar y obtener elementos aleatorios es O (1)

• En términos de recorrer y recuperar consultas, la complejidad temporal de las matrices puede ser O (1), pero la inserción y eliminación requieren juzgar si val existe, lo que hace que la inserción y eliminación superen O (1).

• Las tablas hash pueden completar operaciones de inserción y eliminación en tiempo O(1)

• Entonces: tabla hash + matriz dinámica

Una matriz de longitud variable puede completar la operación de obtener elementos aleatorios en tiempo O (1), pero debido a que no puede determinar si el elemento existe en tiempo O (1), las operaciones de inserción y eliminación no se pueden completar en tiempo O (1). . Una tabla hash puede completar operaciones de inserción y eliminación en tiempo O (1), pero debido a que no puede ubicar un elemento específico según el subíndice, no puede completar la adquisición de elementos aleatorios en tiempo O (1). Para cumplir con la complejidad temporal de insertar, eliminar y obtener elementos aleatorios, es necesario combinar matrices de longitud variable y tablas hash. Los elementos se almacenan en la matriz de longitud variable y cada elemento se almacena en la tabla hash en un manera de longitud variable Subíndice en la matriz.

Durante la operación de inserción, primero determine si val está en la tabla hash. Si ya existe, devuelva falso. Si no existe, inserte val. La operación es la siguiente:

Agregue val al final de la matriz de longitud variable;
la longitud de la matriz de longitud variable antes de agregar val es el índice de subíndice donde se encuentra val, y almacene val y el índice de subíndice en la tabla hash;
devuelve verdadero.

Al eliminar, primero determine si val está en la tabla hash. Si no existe, devuelva falso. Si existe, elimine val. La operación es la siguiente:

Obtenga el índice de subíndice de val de la tabla hash;
mueva el último elemento de la matriz de longitud variable al índice de subíndice y actualice el subíndice del último para indexar en la tabla hash; elimine el último elemento de la matriz de longitud
variable Elemento, elimina val en la tabla hash;
devuelve verdadero.

El objetivo de la operación de eliminación es mover el último elemento de la matriz de longitud variable al subíndice del elemento que se va a eliminar y luego eliminar el último elemento de la matriz de longitud variable. La complejidad temporal de esta operación es O (1) y puede garantizar que los subíndices de todos los elementos en la matriz de longitud variable sean continuos después de la operación de eliminación, lo cual es conveniente para operaciones de inserción y adquisición de elementos aleatorios.

Al obtener un elemento aleatorio, dado que los subíndices de todos los elementos en la matriz de longitud variable son consecutivos, se selecciona un subíndice aleatoriamente y se devuelve el elemento en ese subíndice en la matriz de longitud variable.

3. Código:

class RandomizedSet {
    
    
    List<Integer> nums;
    Map<Integer, Integer> indices;
    Random random;

    public RandomizedSet() {
    
    
        nums = new ArrayList<Integer>();
        indices = new HashMap<Integer, Integer>();
        random = new Random();
    }

    public boolean insert(int val) {
    
    
        if (indices.containsKey(val)) {
    
    
            return false;
        }
        int index = nums.size();
        nums.add(val);
        indices.put(val, index);
        return true;
    }

    public boolean remove(int val) {
    
    
        if (!indices.containsKey(val)) {
    
    
            return false;
        }
        int index = indices.get(val);
        int last = nums.get(nums.size() - 1);
        nums.set(index, last);
        indices.put(last, index);
        nums.remove(nums.size() - 1);
        indices.remove(val);
        return true;
    }

    public int getRandom() {
    
    
        int randomIndex = random.nextInt(nums.size());
        return nums.get(randomIndex);
    }
}

4. Análisis de complejidad:

• Complejidad temporal: la complejidad temporal de la inicialización y diversas operaciones es O (1).

  Complejidad espacial: O (n), donde n es el número de elementos del conjunto. Las matrices y tablas hash que almacenan elementos requieren espacio O(n).

5. Resumen:

El diseño de la complejidad temporal promedio de O (1) es inseparable de la tabla hash.

Generalmente, la inserción, eliminación y recuperación se pueden realizar con matrices, así que simplemente elija matrices, que es más simple.

Puede combinar las dos estructuras de datos según el tema, como: matriz + tabla hash

Si este artículo te resulta útil, recuerda darle un me gusta a Yile, ¡gracias!