1. Conceptos básicos de tablas hash.

Una tabla hash es una estructura de datos que utiliza una función hash para asignar claves a depósitos o ranuras. Permite operaciones rápidas de inserción, búsqueda y eliminación al convertir claves en índices. Las tablas hash se utilizan a menudo en escenarios que requieren una búsqueda eficiente, como diccionarios, cachés y bases de datos.

Estructuras hash comunes

formación
colocar
map (mapping)-py contiene dict (diccionario) y
el conjunto en py es una clave desordenada y no repetible.
El diccionario contiene clave y valor.

Cuando nos encontramos con la necesidad de determinar rápidamente si un elemento aparece en el conjunto, ¡debemos considerar el hash!

Debería poder tener una comprensión básica de las tablas hash después de leer esta publicación de blog. ¡Dale! ¡Completa completamente la tabla hash en un artículo! _Hash Table Qingge_Blog de Qingge Java-Blog CSDN

2. Práctica de algoritmos

2.1 Pregunta 1

Dada una matriz de enteros nums y un valor objetivo entero , busque los dostarget números enteros en la matriz cuya suma es el valor objetivo y devuelva sus subíndices de matriz.target

Puede suponer que cada entrada corresponderá a una sola respuesta. Sin embargo, el mismo elemento de la matriz no puede aparecer repetidamente en la respuesta.

Puede devolver respuestas en cualquier orden.

(1) Método de enumeración violento

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        left = 0
        right = 0
        for i in range(len(nums)):
            for j in range(left+1,len(nums)):
                if nums[j] + nums[left] == target:
                    return [left,j]
                else:
                        j = j + 1
            left = left + 1

Ha pasado mucho tiempo, no esperaba que esto superara el 10%.

(2) tabla hash

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        hash_table = dict()
        for i, num in enumerate(nums):
            if target - num in hash_table:
                return [hash_table[target-num], i]
            else:
                hash_table[num] = i

2.2 Pregunta 49

Se le proporciona una serie de cadenas y se le pide que combine los anagramas . La lista de resultados se puede devolver en cualquier orden.

Un anagrama es una palabra nueva que se obtiene reordenando todas las letras de la palabra original.

Ejemplo 1:

输入: strs =["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

Ejemplo 2:

Entrada: cadenas = [""]
Salida: [[""]]

Ejemplo 3:

Entrada: strs = ["a"]
Salida: [["a"]]

Experiencia: esta pregunta trata principalmente sobre encontrar puntos en común entre palabras heterogéneas con las mismas letras, extraerlas como claves de la tabla hash, y el valor es una lista de palabras heterogéneas con las mismas letras. No lo hice y pensé en ordenar con números en lugar de letras, pero solo pensé en la suma y pensé que sería inútil si no fuera único. Después de leer el foro de discusión, el jefe usó números primos en lugar de letras, de modo que el producto de los números primos es único y las palabras heterogéneas compuestas por las mismas letras tienen las mismas propiedades y pueden almacenarse y representarse en un diccionario. No entiendo la respuesta oficial.

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        map = {
            'a':2,'b':3,'c':5,'d':7,'e':11,'f':13,'g':17,'h':19,'i':23,'j':29,'k':31,'l':37,'m':41,
            'n':43,'o':47,'p':53,'q':59,'r':61,'s':67,'t':71,'u':73,'v':79,'w':83,'x':89,'y':97,'z':101
        }
        resmap={}
        reslist = []
        for str in strs:
            m = 1
            for i in range(len(str)):
                m*=map[str[i]]
            if  not m in resmap:
                resmap[m]=[]
            resmap[m].append(str)
        # print(resmap.values())
        return [j for j in resmap.values()]

2.3 Pregunta 128

Dada una matriz de números enteros sin ordenar nums , encuentre la longitud de la secuencia más larga de números consecutivos (no es necesario que los elementos de la secuencia sean consecutivos en la matriz original).

Diseñe e implemente O(n) un algoritmo con complejidad temporal para resolver este problema.

Ejemplo 1:

Entrada: nums = [100,4,200,1,3,2]
 Salida: 4
 Explicación: La secuencia consecutiva más larga de números es[1, 2, 3, 4]。它的长度为 4。

Ejemplo 2:

Entrada: números = [0,3,7,2,5,8,4,6,0,1]
 Salida: 9

Experiencia: La tabla hash está muy mal controlada, por lo que solo puedo usar el método más estúpido para resolverla con fuerza bruta, pero el tiempo ha excedido el límite.

class Solution(object):
    def longestConsecutive(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums)==0:
            return 0
        if len(nums)==1:
            return 1
        i = 0
        j = 0
        cur_len = 1
        max_len = 1
        for i in range(len(nums) - 1):
            for j in range(len(nums) - 1 - i):
                if nums[j] > nums[j+1]:
                    temp = nums[j+1]   
                    nums[j+1] = nums[j]
                    nums[j] = temp
        
        for k in range(len(nums) - 1):
            if nums[k+1]==nums[k]:
                continue
            elif nums[k+1]==nums[k] + 1:
                cur_len = cur_len + 1
                if max_len < cur_len:
                    max_len = cur_len
            else:
                cur_len = 1
        return max_len


        
        
        return nums

Después de echar un vistazo al análisis, descubrí que el set () utilizado tenía muy poco conocimiento. Después de observar el uso de set (), finalmente escribí una versión. Pero el consumo de tiempo y memoria sigue siendo muy grande.

class Solution(object):
    def longestConsecutive(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        up = 1
        down = 1
        cur_len = 1
        max_len = 1
        if len(nums)==0:
            return 0
        if len(nums)==1:
            return 1
        hash_table = set()
        for i in range(len(nums)):
            hash_table.add(nums[i])
        j = 0
        while j < len(nums)-1:
            hash_table.discard(nums[j])
            if nums[j] + up in hash_table:
                hash_table.remove(nums[j] + up)
                up = up + 1
            elif nums[j] - down in hash_table:
                hash_table.remove(nums[j] - down)
                down = down + 1
            else:
                cur_len = up + down - 1
                up = 1
                down = 1
                if cur_len > max_len:
                    max_len = cur_len
                j = j + 1
        return max_len

Descubrí que se puede usar hash_table=set(nums) y la memoria se ha reducido un poco, pero se ha aumentado mucho.

Leí la versión oficial de la respuesta. Más conciso.

class Solution(object):
    def longestConsecutive(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        cur_len = 1
        max_len = 1
        if len(nums)==0:
            return 0
        if len(nums)==1:
            return 1
        hash_table = set(nums)
        for num in hash_table:
            if num - 1 not in hash_table:
                # 如果表中没有比它小1的,就开始寻找大1的，然后一直往上找
                cur_num = num
                cur_len = 1
                # 如果比它大1存在，则开始计数
                while cur_num + 1 in hash_table:
                    cur_num = cur_num + 1
                    cur_len = cur_len + 1
                if max_len < cur_len:
                    max_len = cur_len
            # 如果有比它小1的，直接不管，继续循环，直到找到没有比它小1的

        return max_len

3. Resumen

Después de completar la pregunta de la tabla hash, descubrí que hay varios puntos clave. Uno es cuándo usarlo. Cuando necesite encontrar rápidamente si un elemento está en un conjunto, debe usar la tabla hash. Una es que es necesario dominar el uso básico de matrices, dict () y set (); de lo contrario, será realmente problemático.

4. Conocimientos requeridos

4.1 Uso básico de matrices

1. Las matrices de Python se dividen en tres tipos:
(1) lista Lista vinculada ordinaria , después de la inicialización, los elementos se pueden agregar dinámicamente mediante métodos específicos.
Método de definición: arr = [elemento]

Artículo Uso de matrices de Python (súper completo)_27Up's Blog-CSDN Blog

a. Inicializar al definir, a = [1,2,[1,2,3]], b. No inicializar al definir, matriz unidimensional: arr = []
del elimina el elemento especificado en la matriz, como por ejemplo: del arr[0]
D. Recorrer la matriz:
para k, v en enumerar (arr):
imprimir k, v
e. Agregar elementos: arr.append('aaa') unidimensional, arr[0] bidimensional.append('aaa')
Si desea insertar en cualquier posición, use arr.insert(n, valor)
Método de lista
L.append(var) #Agregar elementos
L.insert(index,var)
L.pop(var) #Devolver el último elemento y eliminarlo de la lista
L.remove(var) #Eliminar la primera aparición El elemento
L .count(var) #El número de veces que el elemento aparece en la lista
L.index(var) #La posición del elemento, si no, se lanzará una excepción
L.extend(list) #Agregar la lista, es decir , combine la lista en L
L.sort() #Sort
() #Orden inverso

(2) Tupla es una matriz fija . Una vez definida, el número de elementos no se puede cambiar.
Método de definición: arr = (elemento)

Métodos que Tuple no tiene:
[1] No se pueden agregar elementos a la tupla y no existen métodos como agregar, extender e insertar.
[2] Los elementos no se pueden eliminar de la tupla, no existe un método de eliminación o extracción.
[3] Los elementos no se pueden encontrar en tuplas y no existe un método de índice (el índice es una búsqueda, no un índice, y el índice se puede subscribir directamente, como: t [0]).

Una tupla se puede convertir en lista y viceversa.
El método de conversión es: t = lista(t), y viceversa: arr = tupla(arr)

(3) Tipo de diccionario Diccionario , que es una matriz Hash.
Método de definición: arr = {elemento k:v}

#El uso del Diccionario es relativamente simple. Puede almacenar cualquier valor y permite diferentes tipos de valores. El siguiente ejemplo ilustra: #En el siguiente
ejemplo, a es un número entero, b es una cadena y c es una matriz. Este ejemplo ilustra completamente la aplicabilidad de la matriz hash.
dict_arr = {'a': 100, 'b':'niño', 'c':['o', 'p', 'q']}

#Puedes agregar directamente un elemento. Si tiene el mismo nombre, se cambiará el valor del elemento clave original
dict_arr['d'] = 'dog'

#Salir de todas las claves
imprimir dict_arr.keys()

#Imprimir todos los valores
imprimir dict_arr.values()

4.2dict() uso básico

Cuando no necesitamos este elemento, debemos eliminar el elemento del dict. El método pop() elimina rápidamente el elemento. Pero debe especificar la clave del elemento que se eliminará y devolver el valor. <**Nota>**El parámetro del método pop() es la clave en el dict. Cuando la clave no existe, también se producirá un error.
Leer elementos dict. Cree un dict y el dict encontrará la función de valor correspondiente a través de la clave. También puede obtener el valor correspondiente a través de la clave. dict proporciona el método get y pasa la clave como parámetro al método get. No habrá ningún error cuando la clave no exista.
Agregar elementos dict dict es diferente de tupla. dict es variable. Podemos agregar nuevos valores-clave a dict en cualquier momento. El valor puede ser cualquier tipo de elemento, como lista, tupla, etc., como d['Alice' ] La instrucción de asignación =[50,61,66] tiene dos funciones:
1. Cuando la clave no existe, agregue el elemento clave:valor correspondiente al dict.
2. Cuando la clave exista, el dict se actualizará y el valor original se reemplazará con el nuevo valor.
Hay dos formas de atravesar dict en Python
: la primera es atravesar todas las claves del dict y obtener el valor correspondiente a través de la clave.
El segundo método es a través del método items() proporcionado por dict. El método items() devolverá todos los elementos del dict, cada elemento contiene clave y valor. para clave, valor en d.items():
Borrar todos los elementos dict proporciona la función clear() para borrar directamente todos los elementos en el dict. D. claro()

4.1 uso básico de set ()

Artículo Explicación detallada del conjunto de colecciones de Python (súper detallado)_python set collection_blog de LeoATLiang-blog CSDN

Un conjunto es una secuencia desordenada de elementos que no se repiten .
Puede usar llaves { } o la función set() para crear un conjunto. Nota: Para crear un conjunto vacío, debe usar set() en lugar de { } , porque { } se usa para crear un diccionario vacío.
No podemos acceder a los elementos del conjunto haciendo referencia al índice, porque el conjunto está desordenado y los elementos no tienen índice . Sin embargo, puede utilizar un bucle for para recorrer los elementos del conjunto o utilizar la palabra clave in para consultar si existe un valor específico en el conjunto.
El método add() se utiliza para agregar un elemento a la colección; si el elemento agregado ya existe en la colección, no hará nada.
El método update() se utiliza para modificar la colección actual. Puede agregar nuevos elementos o colecciones a la colección actual. Si el elemento agregado ya existe en la colección, el elemento solo aparecerá una vez y los duplicados se ignorarán. update() puede fusionar dos colecciones.
El método remove() se utiliza para eliminar el elemento especificado de la colección. Este método es diferente del método descartar() porque el método remove() causará un error al eliminar un elemento inexistente, mientras que el método descartar() no lo hará.
El método clear() se utiliza para eliminar todos los elementos de la colección.
Para eliminar, utilice la función del .

Reserva de conocimientos-Algoritmos básicos-Tabla hash