d5哈希表练习

第三章 哈希表part01

今日任务 

1.  哈希表理论基础 

1.  242.有效的字母异位词 

1.  349. 两个数组的交集 

1.  202. 快乐数

1.  1. 两数之和   

哈希表理论基础 

什么时候想到用哈希法，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

定义：哈希表是根据关键码的值而直接进行访问的数据结构。

直白来讲其实数组就是一张哈希表。哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素。

哈希函数

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

如果学生的数量大于哈希表的大小怎么办，此时就算哈希函数计算的再均匀，也避免不了会有几位学生的名字同时映射到哈希表 同一个索引下标的位置。此时引入哈希碰撞。

哈希碰撞

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

一般哈希碰撞有两种解决方法， 拉链法和线性探测法。

拉链法

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

线性探测法

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

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

常见的三种哈希结构

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

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

哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

 242.有效的字母异位词 

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

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词

分析：定义一个数组叫做record用来上记录字符串s里字符出现的次数。

需要把字符映射到数组也就是哈希表的索引下标上，因为字符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。

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 j=0;j<t.length();j++)

        {

            hash[t.charAt(j)-'a']--;

        }

        for(int i=0;i<hash.length;i++)

        {

            if(hash[i]!=0)

            return false;

        }

        return true;

    }

}

题目：给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

使用数组来做哈希的题目，是因为题目都限制了数值的大小。如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。遍历hashset需要用增强for循环遍历，因其不能通过下标来获取集合里的值。

Hashset集合作哈希表：

class Solution {

    public int[] intersection(int[] nums1, int[] nums2) {

        if(nums1==null||nums1.length==0||nums2==null||nums2.length==0)

        return null;

        Set<Integer> hash = new HashSet<>();

        Set<Integer> resSet = new HashSet<>();

        for(int i : nums1)

        {

            hash.add(i);

        }

        for(int j : nums2)

        {

            if(hash.contains(j))

            resSet.add(j);

        }

        int[] result = new int[resSet.size()];

        int index = 0;

        for(int i:resSet)

        {

            result[index++] = i;

        }

        return result;

    }

}

数组作为哈希表：

class Solution {

    public int[] intersection(int[] nums1, int[] nums2) {

      int[] hash1 = new int[1002];

      int[] hash2 = new int[1002];

      for(int i=0;i<nums1.length;i++)

      hash1[nums1[i]]++;

      for(int i=0;i<nums2.length;i++)

      hash2[nums2[i]]++;

    ArrayList<Integer> resList = new ArrayList<>();

    for(int i=0;i<1002;i++)

    {

        if(hash1[i]>0&&hash2[i]>0) resList.add(i);

    }

    int[] result = new int[resList.size()];

    int index=0;

    for(int i=0;i<resList.size();i++)

    result[index++] = resList.get(i);

    return result;

        }

}

 202. 快乐数

题目：编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。

所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。

class Solution {

    public boolean isHappy(int n) {

        Set<Integer> hash = new HashSet<>();

        while(n!=1 && !hash.contains(n)){

        hash.add(n);//最开始的n要先放入hash表中。

        n = getNextNum(n);

        }  

        return n == 1;

}

//对取数值各个位上的单数操作：

    private int getNextNum(int n)

    {

        int result = 0;

        int key;

        while(n>0)

        {

        key = n%10;

        result += key*key;

        n/=10;

        }

        return result;

}

}

1. 两数之和 

题目：给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

①：暴力算法：

class Solution {

    public int[] twoSum(int[] nums, int target) {

        for(int i=0;i<nums.length;i++)

        {

            for(int j=i+1;j<nums.length;j++)

            {

                if(nums[i]+nums[j]==target)

                return new int[]{i,j};

            }

        }

        return null;

    }

}

②：哈希表算法：

再强调一下 什么时候使用哈希法，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

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

因此使用哈希表。

我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

再来看一下使用数组和set来做哈希法的局限。

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

此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value再保存数值所在的下标。

接下来需要明确两点：

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

map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）

接下来是map中key和value分别表示什么。

这道题 我们需要 给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。

那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。

所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。

在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

class Solution {

    public int[] twoSum(int[] nums, int target) {

        int[] result = new int[2];

        if(nums==null||nums.length==0) return result;

        Map<Integer,Integer> map = new HashMap<>();

        for(int i=0;i<nums.length;i++)

        {

            int temp = target - nums[i];

            if(map.containsKey(temp))

//如果遍历到则将这对数据的下标存入数组并返回。

            {

                result[0] = i;

                result[1] = map.get(temp);

                break;

            }

//如果没有遍历到则将当前遍历的值和其下标存入到map集合中。

            map.put(nums[i],i);

        }

        return result;

    }

}