Day5|哈希表

哈希表的基本概念

在遇到需要快速判断一个元素是否出现在集合中的时候，此时应当考虑哈希法。

哈希函数将待存储的元素映射为哈希表上的索引，然后通过索引快速知道元素是否在哈希表中。

为了保证映射出来的索引都落在哈希表上，需要对哈希表的size取模。

但是也有可能两个元素经过哈希函数映射到哈希表上后，索引位置一致。这种情形叫做哈希碰撞，有两种解决办法，拉链法和线性探测法。

• 拉链法
  发生冲突的元素存储在当前索引下的链表中

• 线性探测法
  使用线性探测法时，需要先保证哈希表的size大于数据量的size，保证数据有空位可以插入。

使用哈希法解决问题时，考虑使用三种数据：
数组，set （集合），map（映射）

补充知识：Java中的集合

• 在 Java SE 8中，甚至不用写循环。可以调用 forEachRemaining 方法并提供一 lambda
  表达式（它会处理一个元素）。 将对迭代器的每一个元素调用这个 lambda 表达式，直到再没
  有元素为止。
• Iterator接口的remove方法删除上次调用next方法返回的元素，如果没有执行next直接remove，会报IllegalStateException
• SortedSet 和 SortedMap 接口会提供用于排序的比较器对象
• 链表
  链表是一个有序集合，每个对象的位置十分重要，LinkedList.Add方法将对象添加到链表的尾部，add方法被设定总会改变链表，可以根据需要给容器附加许多的迭代器，但是这些迭代器只能读取列表。另外，再单独附加一个既能读又能写的迭代器。
  链表优点：减少在列表中间插入或者删除元素付出代价，如果列表只有少数几个元素，就可以完全使用ArrayList。
• Vector 需要创建动态数组时，两个线程可以安全地访问同一个Vector对象，vector的所有方法都是同步的，但是如果是单个线程，那么可以使用ArrayList，减少时间消耗
• 散列集 散列表为每个对象计算一个整数，称为散列码，散列码是由对象的实例域产生的一个整数，如果自定义类，那么就需要实现类的hashcode方法，必须保证如果a.equals(b)为true，那么就必须保证a,b具有相同的散列码
• 散列表过满就需要进行再散列，如果装填因子为0.75，那么表就会以双倍的桶数进行再散列
• Java 集合类库提供了一个 HashSet 类，它实现了基于散列表的集。可以用 add 方法添加
  元素。contains方法已经被重新定义，用来快速地查看是否某个元素已经出现在集中。它只
  在某个桶中査找元素，而不必查看集合中的所有元素。
• 树集，要使用树集，就必须要能够比较元素，这些元素必须实现Comparable接口
• 优先级队列既可以保存实现了 Comparable 接口的类对象， 也可以保存在构造器中提供的 Comparator 对象。
• HashSet底层是HashMap，HashMap底层是数组+链表+红黑树

学习文章：Java集合介绍

题目

有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

首先使用暴力法，将字符串s中的字母及出现次数提取到一个数组中，t的提取到另一个数组中，最后比较数组是否相等即可证明该字符是否是有效的字母异位词。

 public boolean isAnagram(String s, String t) {
        int[] a=new int[26];
        int[] b=new int[26];
        for(int i=0;i<s.length();i++){
            char temp=s.charAt(i);
            int temp1=temp-'a';
            a[temp1]++;

        }
        for(int i=0;i<t.length();i++){
            char temp=t.charAt(i);
            int temp1=temp-'a';
            b[temp1]++;
        }
        if(Arrays.equals(a,b)){
            return true;
        }
        return false;

    }

时间复杂度为O(N^2)，空间复杂度为O(1)

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
可以将两个数组中的数据存到hashSet中，或者使用数组的方式实现哈希法，使用数组的前提是给内容指定了界限，比如本题指定了nums[i]中的大小为0-1000

public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1==null||nums2==null)
        return new int[0];
        Set<Integer> set1=new HashSet<Integer>();
        Set<Integer> set2=new HashSet<Integer>();
        for(int i=0;i<nums1.length;i++){
            set1.add(nums1[i]);
        }
        for(int i=0;i<nums2.length;i++){
            if(set1.contains(nums2[i])){
                set2.add(nums2[i]);
            }
        }
        return set2.stream().mapToInt(x->x).toArray();
    }

时间复杂度为O(m+n)

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

「快乐数」 定义为：

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

• 思路：使用一个不允许出现重复项的集合记录整个计算sum过程中的数值，如果该数值能在集合中找到，那么说明该过程陷入了循环，应当直接退出循环；但是如果sum刚好为1，说明是快乐数。如果不是处于循环之中，也没有得出快乐数的结论，将sum赋值给n继续循环。
  代码如下：

public boolean isHappy(int n) {
        Set<Integer> set=new HashSet<Integer>();
        while(true){
            int sum=getSum(n);
            if(sum==1){
                return true;
            }else{
                if(set.contains(sum)){
                    return false;
                }else {
                    set.add(sum);

                }
            }
            n=sum;
        }
    }
    int getSum(int n){
        int sum=0;
        while(n>0){
            sum+=(n%10)*(n%10);
            n=n/10;
        }
        return sum;
    }

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

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

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

-思路：该题首先可以考虑到使用暴力法，然后设置双重循环，判断有没有这样的两个数值。然后可以考虑到，强调一下 什么时候使用哈希法，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。
哈希法一般有数组，set（集合），map(映射)，在该处使用数组做哈希法会容易浪费内存，set则只能存储一个键值，在该处需要存储键值以及该数出现的位置。

 public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map=new HashMap<Integer,Integer>();
        int[]a=new int[2];
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                a[0]=map.get(target-nums[i]);
                a[1]=i;
            }else{
                map.put(nums[i],i);
            }
        }
        return a;
    }

时间复杂度为O（n）

• 本题总结
  为什么会想到用哈希表
  哈希表为什么用map
  本题map是用来存什么的
  map中的key和value用来存什么的