哈希表思想的运用

•  哈希思想其最重要的思想就是将数据转换为索引下标

class Solution {
    public char firstUniqChar(String s) {
        char arr[]=s.toCharArray();
        int count[]=new int [26];
        for(char c : arr){
            count[c-'a']++;
        }
        for(char c : arr){
            if(count[c-'a']==1){
                return c;
            }
        }
        return ' ';
    }
}

剑指 Offer 61. 扑克牌中的顺子

• 首先明确，对于大小王的特殊处理
• 如果出现了对子，肯定不是顺子
• 如何判断顺子，我们只要保证最大值和最小值的小于等于4就可以，因为出现了相同的牌，已经再前面的判断中处理了，所以可能都是不重复的牌（0除外）

class Solution {
    public boolean isStraight(int[] nums) {
        int min=14;
        int max=-1;
        int []arr=new int[14];//用来记录是否出现了重复 也就是对子
        for(int i=0;i<nums.length;i++){
            if(nums[i]==0) continue;//用于大小王，先不考虑
            if(arr[nums[i]]==1) return false; //说明出现了对子
            arr[nums[i]]++;
            min=Math.min(min,nums[i]);
            max=Math.max(max,nums[i]);
        }
        return max-min<=4;
    }
}

或者可以使用split()这种方法

class Solution {
    public String reverseWords(String s) {
        String[] strs = s.trim().split(" "); // 删除首尾空格，分割字符串
        StringBuilder res = new StringBuilder();
        for(int i = strs.length - 1; i >= 0; i--) { // 倒序遍历单词列表
            if(strs[i].equals("")) continue; // 遇到空单词则跳过
            res.append(strs[i] + " "); // 将单词拼接至 StringBuilder
        }
        return res.toString().trim(); // 转化为字符串，删除尾部空格，并返回
    }
}

剑指 Offer 03. 数组中重复的数字

class Solution {
    public int findRepeatNumber(int[] nums) {
        int []arr=new int [nums.length];
        for(int i=0;i<nums.length;i++){
            if(arr[nums[i]]==1){
                return nums[i];
            }else{
                arr[nums[i]]++;
            }
        }
        return 0;
    }
}

49. 字母异位词分组

 

 

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String,List<String>> codeToGroup=new HashMap<>();
        for(String s:strs){
            String code=encode(s);
            //把编码相同的字符串放在一起
            if(!codeToGroup.containsKey(code)){
                codeToGroup.put(code,new LinkedList<>());
            }
            codeToGroup.get(code).add(s);
        }
        List<List<String>> res=new LinkedList<>();
        for(List<String> group:codeToGroup.values()){
            res.add(group);
        }
        return res;
    }
    String encode(String s){
        char []count=new char[26];
        for(char c:s.toCharArray()){
            int delta=c-'a';
            count[delta]++;
        }
        return new String(count);
    }
}

• 核心就是关于key的处理，如何区别呢？我们区分一个单词是不是相同的，通过使用的单词的个数是否相同，