Apreciación de las preguntas sobre el algoritmo de dos cadenas

Hoy leecode vio un problema de algoritmo elemental. Siento que mi pensamiento es muy sutil. Por la presente, regístrelo para aprender

---

1. Variantes efectivas de letras

242.

La disforia de letras significa que las letras de las dos cadenas son iguales, el número es el mismo y el orden se puede ignorar.

1 Agrietamiento por fuerza bruta

Mi pensamiento es: use el mapa para contar el número de cada letra y luego recorra dos mapas. comparando. La complejidad temporal del recorrido anidado de dos mapas es O (N²). La complejidad del espacio es O (N).
el código se muestra a continuación:

public boolean isAnagram(String s, String t) {
    
    
        if (s.length() != t.length())
            return false;
        if (s.length() == 0) {
    
    
            return true;
        }
        Map<Character,Integer> ms=new HashMap<>();
        Map<Character,Integer> mt=new HashMap<>();
        char[] chs = s.toCharArray();
        char[] cht = t.toCharArray();
        for (int i=0;i<chs.length;i++){
    
    
            ms.put(chs[i],ms.getOrDefault(chs[i],0)+1);
        }
        for (int j=0;j<cht.length;j++){
    
    
            mt.put(cht[j],mt.getOrDefault(cht[j],0)+1);
        }

        for (Map.Entry<Character,Integer> s1:ms.entrySet()){
    
    
            for(Map.Entry<Character,Integer> s2:mt.entrySet()){
    
    
                Character key = s1.getKey();
                if(mt.get(key)==null || !mt.get(key).equals(s1.getValue())){
    
    
                    return false;
                }
            }
        }
        return true;
    }

Según los resultados estadísticos, tomó menos del 26% del tiempo.

2 Utilice matrices

Ordene las dos matrices de caracteres y luego determine si las dos matrices son iguales. Esto también se puede solucionar. La complejidad del tiempo depende del algoritmo de clasificación. El promedio es O (nlogn)

 public boolean isAnagram(String s, String t) {
    
    
        //特判，长度不同必定不是
        if (s.length()!=t.length()) return false;
        //两个字符串排序后是否相等
        char[] array1 = s.toCharArray();
        char[] array2 = t.toCharArray();
        Arrays.sort(array1);
        Arrays.sort(array2);
        return Arrays.equals(array1,array2);
    }

Esto ya es muy poderoso.

3 Operación de Hash personalizado

Primero convierta dos cadenas en matrices de caracteres. Defina una matriz de caracteres con una longitud de 26. Lo que se almacena es la diferencia entre el valor de la tabla de códigos Ascii correspondiente a cada letra en sy el valor de la tabla de códigos de a. Si hay más de uno, aumente solo. t solo se reduce a sí mismo. Finalmente, vea si esta matriz es 0;

 public static boolean isAnagram(String s, String t) {
    
    
        //总共有26个字母
        char[] arr = new char[26];
        char[] chs = s.toCharArray();
        char[] cht = t.toCharArray();
        //
        for (int i = 0; i < chs.length; i++) {
    
    
            arr[chs[i] - 'a']++;
        }
        for (int j = 0; j < cht.length; j++) {
    
    
            arr[cht[j] - 'a']--;
        }
        for (int k = 0; k < 26; k++) {
    
    
            if (arr[k] != 0) {
    
    
                return false;
            }
        }
        return true;

    }