2020.04.13笔记

2020.04.13笔记

leetcode5 NO.217 存在重复元素

• 题目：给定一个整数数组，判断是否存在重复元素。如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。
• 自己解答：数组排序，然后按序查找是否有相邻元素相等。时间复杂度nlogn，空间复杂度1。

public boolean containsDuplicate(int[] nums) {
    Arrays.sort(nums);
    for (int i = 0; i < nums.length - 1; ++i) {
        if (nums[i] == nums[i + 1]) return true;
    }
    return false;
}

• 优化解答：想过用hashmap，但是超时了，set就可以。数组存入hashset，若有相同key则true，没有则false。时间复杂度n，空间复杂度n。

public boolean containsDuplicate(int[] nums) {
    Set<Integer> set = new HashSet<>(nums.length);
    for (int x: nums) {
        if (set.contains(x)) return true;
        set.add(x);
    }
    return false;
}

leetcode6 NO.136 只出现一次的数字

• 题目：给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
• 自己解答：hashmap表全部存储，找出为1的那一个。map.put会直接覆盖，十分好用XD。时间复杂度n，空间复杂度n。

class Solution {
    public int singleNumber(int[] nums) {
        Map<Integer,Integer> map= new HashMap<Integer,Integer>();
        for(Integer i : nums){
            Integer count = map.get(i);
            count = count == null ? 1 : ++count;
            map.put(i,count);
        }
        for(Integer i : map.keySet()){
            Integer count = map.get(i);
            if(count ==1){return i;}
        }
        return -1;
    }
}

• 优化解答：因为只有两个重复的数字！所以可以用异或！两个相同的数字异或之后为零！！

class Solution {
    public int singleNumber(int[] nums) {
        int res = nums[0];
        for(int i =1; i<nums.length;i++){
            res = res ^ nums[i];
        }
        return res;
    }
}

leetcode7 NO. 350 两个数组的交集2

• 题目：给定两个数组，编写一个函数来计算它们的交集。
• 自己解答：hashmap先存入大数组，然后小数组去找重复项，对完一个删一个，防止小数组有两个相同数组导致重复计算。时间复杂度nums1+nums2，空间复杂度min(nums1,nums2)。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        if(nums1.length < nums2.length){
            return intersect(nums2,nums1);
        }
        HashMap<Integer,Integer> map = new HashMap<>();
        for(Integer i : nums1){
            map.put(i, map.getOrDefault(i,0) +1);
        }
        int k = 0;
        for(Integer i : nums2){
            int num = map.getOrDefault(i,0)+1;
            if(num>1){
                nums1[k] = i;
                k++;
                map.put(i,num-2);
            }
        }
        return Arrays.copyOfRange(nums1,0,k);
    }
}

• 优化解答：排序两个数组，然后对他们进行线性查找，nums1/2小，则nums1/2往后推移，相等都往后。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int num1=0,num2=0,all=0;
        while(num1<nums1.length && num2<nums2.length){
            if(nums1[num1]<nums2[num2]){
                ++num1;
            }else if(nums1[num1]>nums2[num2]){
                ++num2;
            }else if(nums1[num1]==nums2[num2]){
                nums1[all]=nums1[num1];
                all++;
                num1++;
                ++num2;
            }
        }
        return Arrays.copyOfRange(nums1, 0, all);
    }
}