哈希表相关题

https://leetcode-cn.com/problems/single-number/


BM52 数组中只出现一次的两个数字

方法一：
题目给的意思分析之后，很容易想到一种方法，就是用哈希表辅助得到这两个只出现一次的数字。
代码思路：
1、创建一个哈希表
2、当数组元素没有在哈希表中成为key的时候，put进哈希表，当已存在的时候，则remove掉。
3、最后哈希表中剩下的key就是只出现一次的数字
4、遍历key然后返回结果

public int[] FindNumsAppearOnce (int[] array) {
        // write code here
        // 用于返回结果
        int[] res = new int[2];
        // 创建一个哈希表
        HashMap<Integer,Object> set = new HashMap<>();
        for(int i = 0; i < array.length; i++){
            // 如果已经被当作key了，那就直接remove掉
            if(set.containsKey(array[i])){
                set.remove(array[i],null);
            }else{
                // 否则就添加进去
                set.put(array[i],null);
            }
        }
        int i = 0;
        // 最后拿出来放进返回结果的数组中进行返回
        for(Integer num:set.keySet()){
            res[i++] = num;
        }
        return res;
    }

方法二：位运算
对于这道题目，我们先来想另外一个问题：
如果数组中只有一个出现了一次的数字，那么将所有数异或结果就是该数
我们换个角度思考，能不能做个分组，将题目分为两组 ，然后每一组求出其中的出现一次的数字，最后两者一起返回，不就解决问题了吗？
那么我们要如何分组呢？位运算进行分组，我们首先想到的应该是奇偶分组，就是将所有数 &1，此时能将数字分为奇偶两组。
但是这个时候问题又来了，你又不能保证两个数字就一奇一偶，有可能都是奇数也有可能都是偶数呀~
但是，我们想一下，&1的操作，归根到底，是按照二进制最低位的不同来分组的，例如 ： 0011（3） ，0101（5），0100（4），0001（1）
对上面四个数分组，我们都&1，可以分得结果： 0011，0101，0001（奇数） 0100 （偶数）
我们很明显能够知道，当二进制&1结果为1的时候，为奇数，反之为偶数。它们是按照最低位的不同来分组的。

public int[] FindNumsAppearOnce (int[] array) {

        // 先将全部数进行异或运算，得出最终结果
        int tmp = 0;
        for(int num: array){
            tmp ^= num;
        }

        // 找到那个可以充当分组去进行与运算的数
        // 从最低位开始找起
        int mask = 1;
        while((tmp&mask) == 0){
            mask <<= 1;
        }

        // 进行分组，分成两组，转换为两组 求出现一次的数字 去求
        int a = 0;
        int b = 0;
        for(int num:array){
            if((num&mask) == 0){
                a ^= num;
            }else{
                b ^= num;
            }
        }
        // 因为题目要求小的数放前面，所以这一做个判断
        if(a > b){
            int c = a;
            a = b;
            b = c;
        }
        return new int[]{a,b};
    }

BM51 数组中出现次数超过一半的数字

/*
	交换律：a ^ b ^ c <=> a ^ c ^ b
	任何数于0异或为任何数 0 ^ n => n
	相同的数异或为0: n ^ n => 0
	var a = [2,3,2,4,4]
	2 ^ 3 ^ 2 ^ 4 ^ 4等价于 2 ^ 2 ^ 4 ^ 4 ^ 3 => 0 ^ 0 ^3 => 3
*/
class Solution {
    public int singleNumber(int[] nums) {
        var ans=0;
        for(int i = 0;i < nums.length; i++) {
            ans^=nums[i];
        }
        return ans;
    }
}

//方法一：哈希法 时间空间复杂度O(n)
 public int MoreThanHalfNum_Solution(int [] array) {
        if(array == null || array.length == 0) return 0;
        if(array.length == 1) return array[0];
        // hashmap存储数字和它的出现次数
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i<array.length;i++){
            // 若map中没有，则放入hashmap，并将次数置为1
            if(!map.containsKey(array[i])){
                map.put(array[i],1);
            }else if(map.get(array[i]) < array.length/2){
                // 若map中有，且次数少于一半，就将map中的次数加1
                map.put(array[i],map.get(array[i])+1);
            }else{
                // 若map中有，且次数多于或等于一半，则直接返回该数
                return array[i];
            }
        }
        return 0;
    }

//方法二：排序 时间复杂度O(n) ，空间复杂度O(1)
 public int MoreThanHalfNum_Solution(int [] array) {
        if(array == null || array.length == 0) return 0;
        if(array.length == 1) return array[0];
        // 快速排序
        Arrays.sort(array);
        // 返回数组的中间值
        return array[array.length/2];
}

BM53 缺失的第一个正整数

import java.util.*;
public class Solution {
    public int minNumberDisappeared (int[] nums) {
        int n = nums.length;
        HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>(); 
        //哈希表记录数组中出现的每个数字
        for(int i = 0; i < n; i++) 
            mp.put(nums[i], 1);
        int res = 1;
        //从1开始找到哈希表中第一个没有出现的正整数
        while(mp.containsKey(res)) 
            res++;
        return res;
    }
}