day6

1、哈希表理论基础

1. 哈希法的应用场景：
   1. 当需要快速判断一个元素是否出现在集合里的时候，就要考虑哈希法。
   2. 判断一个元素是否出现过
2. 哈希表的概念：
   1. 哈希表是根据关键码的值而直接进行访问的数据结构。
3. 常见的三种哈希结构
   1. 数组
   2. set（集合）
   3. map（映射）
   4. 数组 VS set VS map
      1. 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
      2. set是一个集合，里面放的元素只能是一个key【无序，无重复元素】
      3. map可存放key-value键值对（key与value是一对一的关系，即总能通过指定的key找到对应的value）。HashMap中，key不能重复，value可以重复

2、leetcode242 有效的字母异位词

1. 代码实现

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

3、leetcode394 两个数组的交集

1. 代码实现

   class Solution {
       public int[] intersection(int[] nums1, int[] nums2) {
           HashSet<Integer> nums1Set = new HashSet<Integer>();
           HashSet<Integer> resultSet = new HashSet<Integer>();
   		
   		//遍历数组1，将数组1的元素放入hashset【无重复元素】
           for(int i : nums1){
               nums1Set.add(i);
           }
   		
   		//遍历数组2，判断放有数组1元素的hashset中是否存在数组2中的元素
   		//若存在，则将该元素放入结果集中（hashset，无重复元素）
           for(int i : nums2){
               if(nums1Set.contains(i)){
                   resultSet.add(i);
               }
           }
   		
   		//将结果集合转为数组
           int[] resultArr = new int[resultSet.size()];
           int index=0;
           for(int i:resultSet){
               resultArr[index++] = i;
           }
           return resultArr;
       }
   }
   

4、leetcode202 快乐数

1. 代码实现

   class Solution {
       private int getNext(int n) {
           int totalSum = 0;
           while (n > 0) {
               int d = n % 10;
               n = n / 10;
               totalSum += d * d;
           }
           return totalSum;
       }
   
       public boolean isHappy(int n) {
           Set<Integer> seen = new HashSet<>();
           while (n != 1 && !seen.contains(n)) {
               seen.add(n);
               n = getNext(n);
           }
           return n == 1;
       }
   }
   

5、leetcode1 两数之和

1. 代码实现

   class Solution {
       public int[] twoSum(int[] nums, int target) {
           HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>();
           int[] res = new int[2];
   
           for(int i=0; i<nums.length; i++){
               // 遍历当前元素，并在map中寻找是否有匹配的key
               int searchKey = target-nums[i];
               if(hashMap.containsKey(searchKey)){
                   int index = hashMap.get(searchKey);
                   res[0] = i;
                   res[1] = index;
               } 
                // 如果没找到匹配对，就把访问过的元素和下标加入到map中,map中的存储结构为 {key：数据元素，value：数组元素对应的下标}
               hashMap.put(nums[i], i);
           }
   
           return res;
       }
   }
   

2. ​ 注意：

   1. map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）
   2. 因为要判断元素是否出现，那么这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。
   3. 所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。
   4. 在遍历数组的时候，只需要向map去查询是否有和目前遍历元素比配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。