【代码随想录刷题】Day06 字符串

1.哈希表理论基础

1.1 哈希表

• 哈希表（Hashtable，也称散列表），它是根据关键码的值而直接进行访问的数据结构
• 其实，数组就是一张哈希表

【划重点】哈希表能解决的问题：一般哈希表是用来快速判断一个元素是否出现再集合里。

例如：要查询一个名字是否在这所学校里，用枚举法的话，时间复杂度为O(n)；使用哈希表的话，时间复杂度为O(1)。
我们只需要把学生姓名映射到哈希表上就可以了。这就用到了哈希函数（hash function）。

1.2 哈希函数

哈希函数，把学生的姓名直接映射为哈希表上的索引，然后就可以通过查询索引下标快速知道这位同学是否在这所学校里了。

此时会出现一个问题，如果学生数量大于哈希表的大小，我们又该如何呢？
哈哈哈哈哈哈，哈希碰撞闪亮登场

1.3 哈希碰撞

1.3.1 解释

如图所示，小李和小王都映射到了索引下标 1 的位置，这一现象叫做哈希碰撞。

1.3.2 解决办法

1.3.2.1 拉链法

刚刚小李和小王在索引1的位置发生了冲突，发生冲突的元素都被存储在链表中。 这样我们就可以通过索引找到小李和小王了

（数据规模是dataSize， 哈希表的大小为tableSize）

其实拉链法就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。

1.3.2.2 线性探测法

使用线性探测法，一定要保证tableSize大于dataSize。 我们需要依靠哈希表中的空位来解决碰撞问题。

例如冲突的位置，放了小李，那么就向下找一个空位放置小王的信息。所以要求tableSize一定要大于dataSize ，要不然哈希表上就没有空置的位置来存放 冲突的数据了。如图所示：

1.4 常见的三种哈希结构

当我们想使用哈希法来解决问题的时候，我们一般会选择如下三种数据结构。

• 数组
• set （集合）
• map(映射)

java版详解请看：Java中集合框架详解

2.【242】有效的字母异位词

2.1 题目描述

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true

示例 2: 输入: s = “rat”, t = “car” 输出: false

提示：s 和 t 仅包含小写字母

2.2 解题思路

• 数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。
• 需要定义一个多大的数组呢，定一个数组叫做record，大小为26 就可以了，初始化为0，因为字符a到字符z的ASCII也是26个连续的数值。
• 需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。
• 再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了
• 那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。
• 那么最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。
• 最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。
• 时间复杂度为O(n)，空间上因为定义的是一个常量大小的辅助数组，所以空间复杂度为O(1)

java代码如下：

public boolean isAnagram(String s,String t){
        int[] record=new int[26];
        for (int i=0;i<s.length();i++){
            //不需要记住字符的ASCII码，只要求出一个相对数值即可
            record[s.charAt(i)-'a']++;
        }
        for (int i=0;i<t.length();i++){
            record[t.charAt(i)-'a']--;
        }
        for (int count : record) {
            if (count!=0){
                //如果record数组里如果有的元素不为0，那么s和t一定是谁多了或者少了字符
                return false;
            }
        }
        return true;

    }
}

3.【349】两个数组的交集

3.1 题目描述

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

3.2 解题思路

【注意】题目中“输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序”

此题难点：选择哈希结构

• 首先，转变存储形式：把nums1中的元素转变为使用哈希表进行存储
• 然后，遍历nums2中的元素，并查询nums2中的元素是否在哈希表中出现过
• 若出现过，则将此元素存放在resultSet集合中（因为最后要去重）
  java代码：

public int[] intersection(int[] nums1,int[] nums2){
        if (nums1==null || nums1.length==0 ||nums2==null ||nums2.length==0){
            return new int[0];
        }

        Set<Integer> set=new HashSet<>();//将nums1中的元素存储到哈希表中
        //存储nums2中的在哈希表中出现过的元素
        //由于输出结果是唯一的，所以使用哈希表结构
        Set<Integer> resultSet=new HashSet<>();

        //遍历nums1
        for (int num : nums1) {
            set.add(num);
        }
        //遍历nums2，并判断nums2中的元素是否在哈希表中出现过
        for (int num: nums2) {
            if (set.contains(num)){
                resultSet.add(num);
            }
        }

        //方法一：将结果集合转为数组
       // return resultSet.stream().mapToInt(x->x).toArray();

        //方法二：另外申请一个数组存放resultSet中的元素，最后返回数组
        int[] arr=new int[resultSet.size()];
        int j=0;
        for (int  i : resultSet) {
            arr[j++]=i;
        }
        return arr;

    }

4.【202】快乐数

4.1 题目描述

编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：
输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

4.2 解题思路

• 题目中说“会无限循环”，也就是说，在求和的过程中，sum会重复出现，所以要使用哈希法
• 使用哈希法来判断这个sum是否重复出现，如果重复了就是return false，否则就一直找到sum=1为止
• 另一个解题点是：求和的过程

java代码：

public boolean isHappy(int n){
        Set<Integer> record=new HashSet<>();
        while (n!=1 && !record.contains(n)){
            record.add(n);
            n=getNextNumber(n);
        }
        return n==1;

    }
    private int getNextNumber(int n){
        int res=0;
        while (n>0){
            int temp=n%10;
            res+=temp*temp;
            n=n/10;
        }
        return res;
    }

5.【1】两数之和

5.1 题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

5.2 解题思路

回顾：什么时候使用哈希法
当我们查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要想到用哈希法

在本题中，我们就需要用一个集合来存放我们遍历过的元素，然后再遍历数组的时候去询问这个集合，某元素是否遍历过（也就是是否出现在这个集合）

本题，我们不仅要知道元素是否遍历过，还要知道这个元素对应的下标，需要使用 key value 结构来存放，key存放元素，value存放下标，所以使用map正合适。

【使用数组和set来做哈希法的局限】

• 数组的大小是受限的，而且如果元素很少，而哈希值太大会造成内存空间的浪费
• set是一个集合，里面放的元素只能是一个key，而两数之和这个题目，不仅要判断y是否存在，还要记录y的下标位置，因为要返回x和y的下标，所以set也不能用。

那么，我们就要使用map结构。map是一种key value的存储结构，可以用key保存数值，用value保存数值所在的下标。

5.2.1 重点内容

我们需要明确两点：

• 1.map用来做什么
• 2.map中key和value分别表示什么

这道题 我们需要 给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标
那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。
所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}
在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

如下图所示：

5.2.2 java代码

public int[] twoSum(int[] nums,int target){
        int[] res=new int[2];
        if (nums==null || nums.length==0){
            return res;
        }

        Map<Integer, Integer> map=new HashMap<>();
        for (int i=0;i<nums.length;i++){
            int temp=target-nums[i];// 遍历当前元素，并在map中寻找是否有匹配的key
            if (map.containsKey(temp)){
                res[1]=i;
                res[0]=map.get(temp);
                break;
            }
            map.put(nums[i],i);// 如果没找到匹配对，就把访问过的元素和下标加入到map中
        }
        return res;
    }