LeetCode刷题——查找打卡

查找

主要思想

做题中考虑的基本数据结构：

• 第一类： 查找有无——set

元素'a'是否存在，通常用set：集合
set只存储键，而不需要对应其相应的值。
set中的键不允许重复

• 第二类： 查找对应关系(键值对应)——dict

元素'a'出现了几次：dict-->字典
dict中的键不允许重复

• 第三类： 改变映射关系——map

通过将原有序列的关系映射统一表示为其他

算法应用

1、leetcode349. 两个数组的交集

题目描述：

给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

说明：
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。

解题思路
因为输出结果中的每个元素都是唯一的，所有选用Set数据结构；把nums1记录为set，判断nums2的元素是否在set中，是的话，就放在一个公共的set中，最后公共的set就是我们要的结果。

程序代码（Java版）

	public static int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> set1 = new HashSet<Integer>();
        HashSet<Integer> set2 = new HashSet<Integer>();
        for(int i=0; i<nums1.length; i++) {
        	set1.add(nums1[i]);
        }
        int num = 0;
        for(int i=0; i<nums2.length; i++) {
        	if(set1.contains(nums2[i])){
        		set2.add(nums2[i]);
        	}
        }
        int [] res = new int[set2.size()];
        for(int i : set2) {
        	res[num++] = i;
        }
        return res;
    }

2、leetcode350. 两个数组的交集 II

题目描述：

给定两个数组nums,求两个数组的交集。
-- 如nums1=[1,2,2,1],nums=[2,2]
-- 结果为[2,2]
-- 出现的顺序可以是任意的

程序代码（Java版）

import java.util.ArrayList;
class Solution {
    public static int[] intersect(int[] nums1, int[] nums2) {
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int i=0; i<nums1.length; i++) {
        	if(map.containsKey(nums1[i])) {
        		map.put(nums1[i], map.get(nums1[i])+1);
        	}else {
        		map.put(nums1[i], 1);
        	}
        }
        
        for(int i=0; i<nums2.length; i++) {
        	if(map.containsKey(nums2[i]) && map.get(nums2[i]) > 0) {
        		list.add(nums2[i]);
        		map.put(nums2[i], map.get(nums2[i])-1);
        	}
        }
        int [] res = new int[list.size()];
        for(int i=0; i<list.size(); i++) {
        	res[i] = list.get(i);
        }
        return res;
    }
}

3、leetcode242. 有效的字母异位词

题目描述：

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

程序代码（Java版）

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        int[] counter = new int[26];
        for (int i = 0; i < s.length(); i++) {
            counter[s.charAt(i) - 'a']++;
            counter[t.charAt(i) - 'a']--;
        }
        for (int count : counter) {
            if (count != 0) {
                return false;
            }
        }
        return true;
    }
}

4、leetcode202. 快乐数

题目描述：

编写一个算法来判断一个数是不是“快乐数”。
一个“快乐数”定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。

示例:

输入: 19
输出: true
解释: 
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

程序代码（Java版）

class Solution {
    public static boolean isHappy(int n) {
		HashSet<Integer> res = new HashSet<Integer>();
        while(n != 1) {
        	int sum = 0;
        	while(n > 0) {
        		int temp = n % 10;
        		sum += temp*temp;
        		n = n / 10;
        	}
        	if(res.contains(sum)) {
        		return false;
        	}else {
        		res.add(sum);
        	}
        	n = sum;
        }
        return true;
    }
}

5、leetcode290. 单词规律

题目描述：

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", str = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", str = "dog cat cat dog"
输出: false

示例 4:

输入: pattern = "abba", str = "dog dog dog dog"
输出: false

说明:
你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。

程序代码（Java版）

import java.util.*;
class Solution {
    public boolean wordPattern(String pattern, String str) {
        HashMap<Character, String> map = new HashMap<>();
        HashSet<String> set = new HashSet<>();
        String[] array = str.split(" ");
        if (pattern.length() != array.length) {
            return false;
        }
        for (int i = 0; i < pattern.length(); i++) {
            char key = pattern.charAt(i);
            if (map.containsKey(key)) {
                if (!map.get(key).equals(array[i])) {
                    return false;
                }
            } else {
                if (set.contains(array[i])) {
                    return false;
                }
                map.put(key, array[i]);
                set.add(array[i]);
            }
        }
        return true;
    }
}

做题的速度有待提升，剩下的会补上