【Java完整版 面试必备】Leetcode Top100题目和答案-哈希_leetcode java题库

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 创建一个哈希表，用来存储已遍历过的数字及其对应的索引
        Map<Integer, Integer> numMap = new HashMap<>();
        
        // 遍历数组
        for (int i = 0; i < nums.length; i++) {
            // 计算当前数字与目标值之间的差值
            int complement = target - nums[i];
            
            // 如果差值已经在哈希表中，则说明我们找到了一对解
            if (numMap.containsKey(complement)) {
                // 返回这对解的索引
                return new int[]{numMap.get(complement), i};
            }
            
            // 将当前数字及索引存入哈希表，以便后续查找
            numMap.put(nums[i], i);
        }
        
        // 如果没有找到符合条件的数对，则返回空数组（本题假设一定有解，所以这里理论上不会执行）
        return new int[0];
    }
}

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

public class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        if (strs == null || strs.length == 0) {
            return new ArrayList<>();
        }
        
        // 使用HashMap存储字母异位词分组，键为排序后的字符串，值为该字母异位词组的列表
        Map<String, List<String>> anagramGroups = new HashMap<>();
 
        for (String str : strs) {
            // 对当前字符串排序，得到排序后的字符串作为哈希表的键
            char[] charArray = str.toCharArray();
            Arrays.sort(charArray);
            String sortedStr = new String(charArray);
 
            // 如果排序后的字符串已经在哈希表中，则将当前字符串添加到对应的列表中
            if (!anagramGroups.containsKey(sortedStr)) {
                anagramGroups.put(sortedStr, new ArrayList<>());
            }
            anagramGroups.get(sortedStr).add(str);
        }
 
        // 将哈希表的值（即所有字母异位词分组）收集到一个List中并返回
        return new ArrayList<>(anagramGroups.values());
    }
}

输入：nums = [100,4,200,1,3,2]
输出：4
解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。

import java.util.HashSet;
import java.util.Set;
 
public class Solution {
    public int longestConsecutive(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
 
        Set<Integer> numSet = new HashSet<>();
        for (int num : nums) {
            numSet.add(num);
        }
 
        int maxLength = 0;
 
        for (int num : numSet) {
            // 只有当num-1不存在时，才认为num是新序列的起点
            if (!numSet.contains(num - 1)) {
                int currentNum = num;
                int currentLength = 1;
 
                // 向序列右侧扩展
                while (numSet.contains(currentNum + 1)) {
                    currentNum++;
                    currentLength++;
                }
 
                // 更新最长序列长度
                maxLength = Math.max(maxLength, currentLength);
            }
        }
 
        return maxLength;
    }
}