hash用法

 HashMap:空间换时间，key-value

class Solution {
    public boolean containsDuplicate(int[] nums) {
        /*
        遍历数组，利用hashset
        key--nums.value
        value--nums.index
        如果map.value!-0表示有；循环遍历完都不满足；表示没有
        */
        Set<Integer> set=new HashSet<>();
        for(int num:nums){
            if(set.contains(num)){
                return true;
            }
            set.add(num);
        }
        return false;  
    }
}

set存储集合元素 

class Solution {
    public int[] twoSum(int[] nums, int target) {
        /*
        利用hashmap存储数组对应的值和index；在存储的过程中查找，
        是否包含target-nums[i]的值，存在就返回；不存在
        就存储在map里面，继续查找
        时间复杂度：一次便利o(n)
        空间复杂度：额外申请了hash数组空间o(n)
        空间换时间
        //暴力便立法：o(n2)两次便利
        */
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            int complaentNum=target-nums[i];
            if(map.containsKey(complaentNum)){
                return new int[]{i,map.get(complaentNum)};
            }
            map.put(nums[i],i);
        }
        return null;
    }
}

hashmap统计不重复元素

class Solution {
    public int findLHS(int[] nums) {
        /*利用hashmap思想：map--<key,value>
        key:不重复元素
        value：元素出现的次数
        遍历map集合：如果存在比key>=1的元素，计算出两组元素的个数，与最大值进行比较
        */
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
        }
        
        int longest=0;
        for(int key:map.keySet()){
            if(map.containsKey(key+1)){
                longest=Math.max(longest,map.get(key)+map.get(key+1));
            }
        }
        return longest;                         
    }
}

 hashmap求一个数组中出现连续元素个数+出现最长连续元素包含的元素个数

class Solution {
    public int longestConsecutive(int[] nums) {
        /*hashmap存储key,value：key表示数组中的元素，value表示【1，2，3】出现连续元素的个数
        先用一个函数求出连续元素出现的map
        在求出最大的连续元素个数
        */
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int num:nums){
            //每个元素value为1
            map.put(num,1);
        }
        
        for(int num:nums){
            //以当前元素为起始元素的连续元素以及出现连续元素的个数
            forWard(map,num);
        }
        
        return maxCount(map);
    }
    
    private int forWard(HashMap<Integer,Integer> map,int num){
        
        //如果元素不包含在map里面
        if(!map.containsKey(num)){
            return 0;
        }
        int cnt=map.get(num);
        if(cnt>1){
            return cnt;
        }
        //求连续元素
        cnt=forWard(map,num+1)+1;
        map.put(num,cnt);
        return cnt;
    }
    //在集合中求出元素存在的最长子序列
     private int maxCount(HashMap<Integer,Integer> map){
         int max=0;
         for(int key:map.keySet()){
             max=Math.max(max,map.get(key));
         }
         return max;
     }
}