输入： head = [3,2,0,-4], pos = 1
输出： 返回索引为 1 的链表节点
解释： 链表中有一个环，其尾部连接到第二个节点。
复制代码

输入： head = [1,2], pos = 0
输出： 返回索引为 0 的链表节点
解释： 链表中有一个环，其尾部连接到第一个节点。
复制代码

输入： head = [1], pos = -1
输出： 返回 null
解释： 链表中没有环。
复制代码

public static ListNode detectCycle(ListNode head) {
    // 搞两个链表，接收 head
    // A是慢链表，B是快链表
    ListNode nodeA = head;
    ListNode nodeB = head;
    // 判断该链表是否为环形链表
    boolean flag = false;
    while(nodeB != null && nodeB.next != null){
        nodeA = nodeA.next;
        nodeB = nodeB.next.next;
        if (nodeA == nodeB){
            flag = true;
            break;
        }
    }
    // 如果为环形链表，判断入口位置
    if (flag){
        nodeA = head;
        while(nodeA != nodeB){
            nodeA = nodeA.next;
            nodeB = nodeB.next;
        }
        return nodeA;
    }
    return null;
}
复制代码

输入: s = "anagram", t = "nagaram"
输出: true
复制代码

输入: s = "rat", t = "car"
输出: false
复制代码

public static boolean isAnagram(String s, String t) {
    int[] array = new int[26];
    char[] charsS = s.toCharArray();
    char[] charsT = t.toCharArray();
    for (int i = 0; i < charsS.length; i++) {
        array[charsS[i] - 'a'] ++;
    }
    for (int i = 0; i < charsT.length; i++) {
        array[charsT[i] - 'a'] --;
    }
    for (int i = 0; i < array.length; i++) {
        if (array[i] != 0){
            return false;
        }
    }
    return true;
}
复制代码

输入： ransomNote = "a", magazine = "b"
输出： false
复制代码

输入： ransomNote = "aa", magazine = "ab"
输出： false
复制代码

输入： ransomNote = "aa", magazine = "aab"
输出： true
复制代码

public static boolean canConstruct(String ransomNote, String magazine) {
    int[] array = new int[26];
    for (char c : ransomNote.toCharArray()) {
        array[c - 'a']++;
    }
    for (char c : magazine.toCharArray()) {
        array[c - 'a']--;
    }
    for (int i : array) {
        if (i > 0){
            return false;
        }
    }
    return true;
}
复制代码

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

输入: strs = [""]
输出: [[""]]
复制代码

输入: strs = ["a"]
输出: [["a"]]
复制代码

public static List<Integer> findAnagrams(String s, String p) {
    List<Integer> list = new ArrayList<>();
    // 求出 p的长度
    int lengthP = p.length();
    // 字符串 s转换成 char数组
    char[] chars = s.toCharArray();
    // 获取 p的哈希表
    int[] array = new int[26];
    for (char c : p.toCharArray()) {
        array[c -'a'] ++;
    }
    // 循环遍历
    for (int i = 0; i < chars.length - lengthP + 1; i++) {
        int[] array1 = new int[26];
        for (int j = 0; j < lengthP ; j++) {
            array1[chars[i + j] - 'a']++;
        }
        // 判断当前长度的字符串是否和p是异步词
        if (Arrays.equals(array, array1)){
            list.add(i);
        }
    }
    return list;
}
复制代码

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
复制代码

输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
复制代码

public static List<List<String>> groupAnagrams(String[] strs) {
    // 定义返回值
    List<List<String>> result = new ArrayList<>();
    // 存储相同字母的单词
    Map<String, List<String>> map = new HashMap<>();
    // 遍历 strs
    int[] array = new int[26];
    String s, t;
    for (String str : strs) {
        for (char c : str.toCharArray()) {
            array[c - 'a']++;
        }
        List<String> strings;
        s = String.valueOf(Arrays.toString(array));
        if (map.containsKey(s)) {
            strings = map.get(s);
        }else{
            strings = new ArrayList<>();
        }
        strings.add(str);
        map.put(s, strings);
        array = new int[26];
    }
    for (Map.Entry<String, List<String>> listEntry : map.entrySet()) {
        result.add(listEntry.getValue());
    }
    return result;
}
复制代码