哈希表之有效的字母异位词

哈希表

有效的字母异位词

242. 有效的字母异位词 - 力扣（LeetCode） (leetcode-cn.com)

题目不难，从这个题目里可以学习到一些Java的小操作和小细节。

我的解法

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] letter_hash = new int[26];
        int len_s = s.length();
        int len_t = t.length();
        for (int i = 0; i < len_s; ++i) {
            int index = (int)(s.charAt(i)) - (int)'a';
            ++letter_hash[index];
        }
        for (int i = 0; i < len_t; ++i) {
            int index = (int)(t.charAt(i)) - (int)'a';
            --letter_hash[index];
        }
        for(int i = 0; i < 26; ++i) {
            if (letter_hash[i] != 0)
            return false;
        }
        return true;
    }
}

标准解法

class Solution {
    public boolean isAnagram(String s, String t) {

        int[] record = new int[26];
        for (char c : s.toCharArray()) {//这里有一种新的遍历方法
            record[c - 'a'] += 1;//char类型可以直接当作int来使用，这一点和C语言一样
        }
        for (char c : t.toCharArray()) {
            record[c - 'a'] -= 1;
        }
        for (int i : record) {
            if (i != 0) {
                return false;
            }
        }
        return true;
    }
}

383. 赎金信 - 力扣（LeetCode） (leetcode-cn.com)

没啥区别，只不过判断条件有些不一样

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] leter_hash = new int[26];
        for (char c:magazine.toCharArray()) {
            ++leter_hash[c - 'a'];
        }
         for (char c:ransomNote.toCharArray()) {
            --leter_hash[c - 'a'];
        }
        for (int i= 0; i < 26; ++i) {
            if (leter_hash[i] < 0) {
                return false;
            } 
        }
        return true;
    }
}

49. 字母异位词分组 - 力扣（LeetCode） (leetcode-cn.com)

直觉上的思路，本质上是通过字母为字符串进行分组。异位的分组符合哈希的原理。

解法1：排序

思路一，每个字符串都不一样，但是排序之后肯定是一样的。因此，可以对每个字符串进行排序，再分组。

这种做法对所有的数字型，字母型变量都适用。

public class Ai {
    public static void main(String[] args) {
        String[] strs = {"eat", "tea", "tan", "ate", "nat", "bat"};
        System.out.println(groupAnagrams(strs));
    }
    public static List<List<String>> groupAnagrams(String[] strs) {
        Map<String,List<String>> map = new HashMap<>();//String用来存储key,List<String>用来存储某个key对应的结果
        for (int i = 0; i < strs.length; i++) {
        //使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
            byte[] temp = strs[i].getBytes();
 
            Arrays.sort(temp);
            String key = new String(temp);
            //这个可以替代if判断
            List<String> list = map.getOrDefault(key,new ArrayList<String>());
            list.add(strs[i]);
            map.put(key,list);
        }
        return new ArrayList<>(map.values());
    }
}

每读一个字符串进来，都进行一个判定，看是否属于已经知道的分组，如果是，就加到那个组去，如果不是就直接返回。每次的结果都存储在二维List的一个List里。

解法2：双重哈希

优势：免去了每个str的排序。

利用了每个字符串都是由小写字母构成的优势。可以将每个字符串映射成一个相同的26位哈希表。

public List<List<String>> groupAnagrams2(String[] strs) {
        Map<String,List<String>> res = new HashMap<>();
        for (String temp: strs) {
            int[] hashStrTemp = new int[26];
           // String hashStr = "#";
            StringBuilder hashStr = new StringBuilder();
            for (char c:temp.toCharArray()) {
                ++hashStrTemp[c-'a'];
                //System.out.println(hashStrTemp[c-'a']);
            }
            for (int num: hashStrTemp) {
                hashStr.append(num);
                hashStr.append("#");
            }
            List<String> value = res.getOrDefault(hashStr.toString(), new ArrayList<>());
           // System.out.println(hashStr);
            value.add(temp);
            res.put(hashStr.toString(), value);
        }
        return new ArrayList<>(res.values());
    }

可以将里面的一部分String换成StringBuilder提升速度。

解法四：双重哈希plus版

可以直接使用Arrays.equals()方法来解决问题。

438. 找到字符串中所有字母异位词 - 力扣（LeetCode） (leetcode-cn.com)

解法一

类似上面题目的排序的做法，定好窗口大小，走一步做一个新的窗口，进行一个新的排序。

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> res = new ArrayList<>();
        int left = 0, right = p.length();
        char [] temp = p.toCharArray();
        Arrays.sort(temp);
        //String sortedP = new String(temp);
        while (right <= s.length()) {
            char [] temp1 = s.substring(left, right).toCharArray();
            Arrays.sort(temp1);
            if (Arrays.equals(temp, temp1)) {
                res.add(left);
            }
            left++;
            right++;
        }
        return res;
    }
}

解法二滑动窗口

public List<Integer> findAnagrams(String s, String p) {
       List<Integer> res = new ArrayList<>();
       int slen =s.length();
       int plen = p.length();
       if (slen < plen)
           return res;
       int left =0 , right = plen - 1;
       int[] window_count = new int[26];
       int[] p_count = new int[26];
       // 对p中的串进行统计
       for (char c:p.toCharArray()) {
           p_count[c-'a']++;
       }
       char[] sCharArray = s.toCharArray();
       // 窗口初始化
        for(int i = 0; i < plen; ++i) {
            window_count[sCharArray[i]-'a']++;
        }
        if (Arrays.equals(window_count,p_count)) {
            res.add(0);
        }
       while (right < slen - 1) {
           window_count[sCharArray[left++]-'a']--;
           window_count[sCharArray[++right]-'a']++;
           if (Arrays.equals(window_count,p_count)) {
               res.add(left);
           }
       }
       return res;
    }

设置一个和p串大小相同的滑动窗口，统计滑动窗口各字母的数量，随着滑动窗口的滑动，对窗口中的字符数量进行统计更新。

注意：

• 对于滑动窗口类的题目，开始滑动之前需要将所有的初始情况都设定好。比如在本题中，应将滑动窗口的数据初始化为第一个窗口；
• 可以使用Arrays.equals(int[],int[])来对两个数据进行快速的比较；
• 在设计到字符串操作的情况下，可以将使用String str.toCharArray()方法将String转成字符数组以便处理；
• 注意滑动窗口的操作：left是还原之后再滑动，right是滑动之后再修改。
• 其实CharAt(i)的速度比toCharArray()更快。这里可以再优化些

解法三：优化的滑动窗口

本解法思路来自于leetcode官方。

public List<Integer> findAnagrams(String s, String p) {
        List<Integer> res = new ArrayList<>();
        int slen = s.length();
        int plen = p.length();
        if (slen < plen) {
            return res;
        }
        int[] count = new int[26];
        int left = 0,right = plen - 1;
        int differ = 0;
        // 此出初始化循环窗口记录
        for (int i = 0; i <= right; ++i) {
            ++count[p.charAt(i) - 'a'];
            --count[s.charAt(i) - 'a'];
        }
        for (int i: count) {
            if (i != 0)
            ++differ;
        }
        if (differ == 0)
            res.add(0);
        while (right < slen - 1) {
            // 滑动窗口左移
            ++count[s.charAt(left) - 'a'];
            if (count[s.charAt(left) - 'a'] == 0) { //由-1变0
                differ--;
            }
            else if(count[s.charAt(left) - 'a'] == 1) { //由0变1
                differ++;
            }
            ++left;
            ++right;
            --count[s.charAt(right) - 'a'];
            if (count[s.charAt(right) - 'a'] == 0) { //由-1变0
                differ--;
            }
            else if(count[s.charAt(right) - 'a'] == -1) { //由0变1
                differ++;
            }
            if (differ == 0)
                res.add(left);
        }
        return res;
    }

没有必要每次都重新比较窗口中的每一个字符的数量。可以使用一个count[]数组来记录滑动窗口变化的过程中，有多少个字母不一致。count记录p减去窗口的差值。每次窗口滑动时，窗口左侧的字符被加回，窗口右侧的字符被减去，滑动窗口中间的字符没有变化，因此只要考虑两侧的变化即可。

解法四：双指针变长滑动窗口

上面的各种方法都是固定窗口大小进行滑动，而本方法是一个变长的滑动窗口。

/while中有两种操作，通过窗口的调整，有两种操作，右移对资源进消耗，左移对资源进行补充。当窗口右侧右移时，会不断对资源进行消耗，因此会出现两种情况：count[s.charAt(high) - ‘a’] > 0，即可以进行消耗count[s.charAt(high) - ‘a’] <= 0，不够消耗。此时，只能对左侧窗口进行滑动，释放一个资源；只要滑动过，就一定所有的窗口内的字符都已经进行了匹配。即：两个字符串长度一样&一个字符串中所有的字符都能在另一个字符中找到<==>是字母异位的

public List<Integer> findAnagrams2(String s, String p) {
        List<Integer> res = new ArrayList<>();
        int[] count = new int[26];
        int slen = s.length();
        int plen = p.length();
        int low = 0, high = 0;
        //对资源进行初始化，如果count中的每个资源都恰好被消耗掉，说明此时被匹配掉。
        for (int i = 0; i < plen; ++i) {
            count[p.charAt(i) - 'a']++;
        }
       
        while (high < slen) {
            if (count[s.charAt(high) - 'a'] > 0) { // 资源没有消耗掉
                count[s.charAt(high++) - 'a']--; // 把多余的资源消耗掉
                if (high - low == plen) {
                    res.add(low);
                }
            }
            else {
                count[s.charAt(low++) - 'a']++;
            }
        }
        return res;
    }