打卡算法-哈希表-20230504

1.字符串t是s的异位词

1.1 手写，hashmap   时间复杂度O(n) + 空间 O(n)

public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        Map<Character, Integer> characterMap = new HashMap<>();
        for (int i =0; i< s.length();i ++) {
            if (characterMap.containsKey(s.charAt(i))) {
                characterMap.put(s.charAt(i), characterMap.get(s.charAt(i)) + 1);
            }else {
                characterMap.put(s.charAt(i), 1);
            }
        }
        for (int i =0; i< t.length();i ++) {
            if (!characterMap.containsKey(t.charAt(i))) {
                return false;
            }
            Integer value = characterMap.get(t.charAt(i)) - 1;
            if (value <= 0) {
                characterMap.remove(t.charAt(i));
            }else  {
                characterMap.put(t.charAt(i), value);
            }
        }
        return characterMap.isEmpty();
    }

1.2 数组写法，常量数组

public boolean isAnagram(String s, String t) {
        int[] record = new int[26];

        for (int i = 0; i < s.length(); i++) {
            record[s.charAt(i) - 'a']++;     // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
        }

        for (int i = 0; i < t.length(); i++) {
            record[t.charAt(i) - 'a']--;
        }
        
        for (int count: record) {
            if (count != 0) {               // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        return true; 
    }

2.数组交集

2.1  手写，用了set的内置方法，时间O(2*n + n)，空间 O(4*n)

public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set = new HashSet<Integer>(nums1.length);
        for (int i : nums1) {
            set.add(i);
        }
        Set<Integer> set2 = new HashSet<Integer>(nums2.length);
        for (int i : nums2) {
            set2.add(i);
        }
        set.retainAll(set2);
        return set.stream().mapToInt(Integer::intValue).toArray();
    }

2.2 手写，用了一个set.时间O(n)，空间 O(n)

public int[] intersection1(int[] nums1, int[] nums2) {
        Set<Integer> set = new HashSet<Integer>(nums1.length);
        for (int i : nums1) {
            set.add(i);
        }
        int [] result = new int[nums1.length];
        int count = 0;
        for (int i : nums2) {
            if (set.contains(i)) {
                result[count++] = i;
                set.remove(i);
            }
        }
        int []realResult = new int[count];
        System.arraycopy(result, 0, realResult, 0, count);
        return realResult;
    }

3.判断快乐数

「快乐数」 定义为：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/happy-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

3.1 手写,栈

public boolean isHappy(int n) {

        Stack<Integer> stack = new Stack<>();
        while (n != 0) {
            stack.push(n%10);
            n /= 10;
        }
        return isHappy(stack);
    }

    private boolean isHappy(Stack<Integer> stack) {
        // 如果只有一位数是1，则是快乐数
        if (stack.size() == 1) {
            if (stack.peek() == 1 || stack.peek() == 7) {
                return true;
            }else  {
                return false;
            }
        }
        int result = 0;
        while (!stack.isEmpty()) {
            Integer pop = stack.pop();
            int temp = pop;
            result += temp * temp;
        }
        return isHappy(result);
    }

 3.2 哈希表

public boolean isHappyHash(int n) {
        Set<Integer> sum = new HashSet<>();
        return  getResult(sum, n);
    }

    private boolean getResult(Set<Integer> set,int n) {
        int sumNumber =0;
        while (n != 0) {
            int x = n % 10;
            sumNumber += x*x;
            n /= 10;
        }
        if (sumNumber == 1) {
            return true;
        }
        if (set.contains(sumNumber)) {
            return false;
        }
        set.add(sumNumber);
        return getResult(set, sumNumber);
    }

4. 两数之和

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

5. 四数之和

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

int count = 0;
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer, Integer> nums1Plus2 = new HashMap<>();
        HashMap<Integer, Integer> nums3Plus4 = new HashMap<>();
        buildMap(nums1Plus2, nums1, nums2);
        buildMap(nums3Plus4, nums3, nums4);
        
        nums1Plus2.forEach((key, value) -> {
            if (nums3Plus4.containsKey(-key)) {
                count += value * nums3Plus4.get(-key);
            }
        });
        return count;
    }

    private void buildMap(HashMap<Integer, Integer> nums1Plus2, int[] nums1, int[] nums2) {
        for (int aNums1 : nums1) {
            for (int aNums2 : nums2) {
                int tempNum = aNums1 + aNums2;
                if (nums1Plus2.containsKey(tempNum)) {
                    nums1Plus2.put(tempNum, nums1Plus2.get(tempNum) + 1);
                } else {
                    nums1Plus2.put(tempNum, 1);
                }
            }
        }
    }

6.四数相加

力扣

int count = 0;
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer, Integer> nums1Plus2 = new HashMap<>();
        HashMap<Integer, Integer> nums3Plus4 = new HashMap<>();
        buildMap(nums1Plus2, nums1, nums2);
        buildMap(nums3Plus4, nums3, nums4);
        
        nums1Plus2.forEach((key, value) -> {
            if (nums3Plus4.containsKey(-key)) {
                count += value * nums3Plus4.get(-key);
            }
        });
        return count;
    }

    private void buildMap(HashMap<Integer, Integer> nums1Plus2, int[] nums1, int[] nums2) {
        for (int aNums1 : nums1) {
            for (int aNums2 : nums2) {
                int tempNum = aNums1 + aNums2;
                if (nums1Plus2.containsKey(tempNum)) {
                    nums1Plus2.put(tempNum, nums1Plus2.get(tempNum) + 1);
                } else {
                    nums1Plus2.put(tempNum, 1);
                }
            }
        }
    }

7.赎金信

力扣

 public boolean canConstruct(String ransomNote, String magazine) {
int[] charArray = new int[26];
        for (int i = 0; i< magazine.length(); i++) {
            charArray[magazine.charAt(i) - 'a']++;
        }
        for (int i = 0; i< ransomNote.length(); i++) {
            charArray[ransomNote.charAt(i) - 'a']--;
        }
        for (int i : charArray) {
            if (i <0) {
                return false;
            }
        }
        return true;
    }

8.三数之和

旧代码

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        if (nums == null || nums.length < 3) {
            return result;
        }
        Arrays.sort(nums);
        // huisu
        // 雙指針+去重
        for (int i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            int j = i + 1, k = nums.length - 1;
            while (j < k) {
                int sum = nums[i] + nums[j] + nums[k];
                if (sum == 0) {
                    List<Integer> item = new ArrayList<>();
                    item.add(nums[i]);
                    item.add(nums[j]);
                    item.add(nums[k]);
                    result.add(item);
                    j++;
                    k--;
                    while (j < k && nums[j] == nums[j-1] && nums[k+1] == nums[k]) {
                        j++;
                        k--;
                    }
                } else if (sum < 0) {
                    j++;
                } else {
                    k--;
                }
            }

        }
        return result;
    }

9、四数之和

力扣

public List<List<Integer>> fourSum(int[] nums, int target) {
        if (nums.length < 4) {
            return new ArrayList<>();
        }
        List<List<Integer>> result = new ArrayList<>();
        // 三指针了
        Arrays.sort(nums);
        Set<String> last2Number = new HashSet<>();
        for (int i = 0; i<= nums.length - 4; i++) {
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }
            for (int j = i+1; j<=nums.length -3; j++) {
                if (last2Number.contains(nums[i] + "_" + nums[j])) {
                    continue;
                }
                int m = j+1, k = nums.length -1;
                while (m < k) {
                    long sumReverse  = (long) target - nums[i] - nums[j] - nums[m] - nums[k];
                    if (sumReverse == 0) {
                        List<Integer> tempList = new ArrayList<>();
                        tempList.add(nums[i]);
                        tempList.add(nums[j]);
                        tempList.add(nums[m]);
                        tempList.add(nums[k]);
                        result.add(tempList);
                        m++;
                        k--;
                        last2Number.add(nums[i] + "_" + nums[j]);
                        while (m < k && nums[m] == nums[m-1] && nums[k] == nums[k+1]) {
                            m++;
                            k--;
                        }
                    }else if (sumReverse > 0) {
                        m++;
                    }else {
                        k--;
                    }
                }
            }
        }
        return result;
    }