[LeetCode] HashMap题目总结
1. Two Sum
找出数组中加起来等于target的两个数。每一个输入有且仅有一个解，但是同一个元素不能使用两次。
可以使用HashMap + 单遍循环，key为数组中的元素，value为下标。如果hashmap中已经存储过target - nums[i]了，那么就找到了一对结果。如果没有存储过target - nums[i]，那么就将(nums[i] , i)放入HashMap。
class Solution {
public int[] twoSum(int[] nums, int target) {
HashMap<Integer, Integer> map = new HashMap<>();//key:number Value:index
int [] ans = new int [2];
for(int i = 0; i < nums.length; i++){
if(map.containsKey(target - nums[i])){
ans[0] = map.get(target - nums[i]);
ans[1] = i;
break;
}
map.put(nums[i], i);
}
return ans;
}
}
3. Longest Substring Without Repeating Characters
给定一个字符串，找出最长的没有重复字符的子串。
滑动窗口+HashMap。HashMap的key是出现的字符，value是该字符的下标。right指针向右移动时，如果发现HashMap已经有了right指向的字符，那么说明该字符重复了，而该字符的位置正是该字符在HashMap中的value值。于是可以直接将left指针移动到该字符的下一位置。
class Solution {
public int lengthOfLongestSubstring(String s) {
char [] arr = s.toCharArray();
int left = 0;
int right = 0;
int ans = 0;
HashMap<Character,Integer> map = new HashMap<>();
for(; right < arr.length; right++){
if(map.containsKey(arr[right])){
left = Math.max(left, map.get(arr[right])+1);
}
ans = Math.max(ans, right - left +1);
map.put(arr[right], right);
}
return ans;
}
}
30. Substring with Concatenation of All Words
给定一个字符串s，和一个单词列表words，words中的每个词长度相等。需要在s中寻找，包含全部词，且每个词只出现一次，没有任何多余其他字符的子串。
本题使用HashMap来存储words中的词。key是词，value是该词在words中出现次数。
words中每个词的长度都是一样的，我们可以假设每个词的长度为length，而一共有n个词，所以满足要求的子串必然是长度为 n * length 的子串
于是我们遍历每一个长度为 n * length的子串，子串也有自己的HashMap，如果子串的某一个词在words的HashMap中没有，或者这个词在子串中出现的次数大于words的HashMap，那么这个子串就不符合要求。当遍历完整个字串之后，如果这个子串没有break掉，那就是一个正确的解。
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
List<Integer> ans = new ArrayList<>();
if(s == null || s.length() == 0 || words == null || words.length==0){
return ans;
}
int numOfWords = words.length;
int lenOneWord = words[0].length();
int len = numOfWords * lenOneWord;
HashMap<String, Integer> map = new HashMap<>();
for(String str: words){
map.put(str, map.getOrDefault(str,0)+1);
}
for(int i = 0 ; i <= s.length() - len;i++){
HashMap<String, Integer> strCount = new HashMap<>();
int j = 0;
for(; j < numOfWords; j++){
String subs = s.substring(i+j*lenOneWord, i+(j+1)*lenOneWord);
if(!map.containsKey(subs)){
break;
}
strCount.put(subs , strCount.getOrDefault(subs, 0)+1 );
if(strCount.get(subs) > map.get(subs)){
break;
}
}
if(j == numOfWords){
ans.add(i);
}
}
return ans;
}
}
36. Valid Sudoku
判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。
1 . 数字 1-9 在每一行只能出现一次。
2 . 数字 1-9 在每一列只能出现一次。
3 . 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
做法很简单，为每一行每一列每一个3x3宫都建一个HashMap，这题可真HashMap。
HashMap也可以用一个长度为9的数组替代。
class Solution {
public boolean isValidSudoku(char[][] board) {
HashMap<Character, Integer> rows[] = new HashMap [9];
HashMap<Character, Integer> columns[] = new HashMap[9];
HashMap<Character, Integer> box[] = new HashMap[9];
for(int i = 0; i <9; i++){
rows[i] = new HashMap<Character, Integer>();
columns[i] = new HashMap<Character, Integer>();
box[i] = new HashMap<Character, Integer>();
}
for(int i = 0; i < 9; i++){
for(int j = 0; j <9; j++){
if(board[i][j] == '.'){
continue;
}
rows[i].put(board[i][j] , rows[i].getOrDefault(board[i][j], 0) + 1);
columns[j].put(board[i][j] , columns[j].getOrDefault(board[i][j], 0) + 1);
int numOfBox = (i/3) * 3 + (j/3);
box[numOfBox].put(board[i][j] , box[numOfBox].getOrDefault(board[i][j], 0) + 1);
if(rows[i].get(board[i][j]) >1 ||
columns[j].get(board[i][j]) >1 ||
box[numOfBox].get(board[i][j]) >1){
return false;
}
}
}
return true;
}
}
159. Longest Substring with At Most Two Distinct Characters
给定一个字符串，找出使用字符不超过两个的最长子串。
本题和 3. Longest Substring Without Repeating Characters很接近，还是滑动窗口+HashMap。HashMap的key是出现的字符，value是该字符出现的次数。right指针向右移动时，如果发现HashMap的长度已经为2了，并且没有hashmap所包含的字符，那么就需要从hashmap中剔除一些key了，于是left指针开始移动，直到hashMap的长度小于2为止。
class Solution {
public int lengthOfLongestSubstringTwoDistinct(String s) {
if(s == null || s.length() == 0){
return 0;
}
char [] arr = s.toCharArray();
int left = 0;
int right = 0;
HashMap<Character, Integer> map = new HashMap<>();
int maxLength = 0;
for(; right < arr.length; right ++){
if(map.size() == 2 && !map.containsKey(arr[right])){
while(map.size() >= 2 ){
map.put(arr[left], map.get(arr[left])-1 );
if(map.get(arr[left]) <= 0){
map.remove(arr[left]);
}
left ++;
}
}
map.put(arr[right], map.getOrDefault(arr[right] , 0)+1 );
maxLength = Math.max(maxLength, right - left +1);
}
return maxLength;
}
}
290. Word Pattern
一个字符和一个单词有一对一的双向映射。给出两个字符串，判断第二个字符串中的单词是否能够和第一个字符串中的字符构成一对一的双向映射。
注意这里是一对一的双向映射，所以在存入hashmap前，不仅需要检查key中是否有重复，还需要检查value是否有重复。
class Solution {
public boolean wordPattern(String pattern, String str) {
if(pattern == null || pattern.length() == 0 || str == null || str.length()== 0){
return false;
}
HashMap<Character, String> map = new HashMap<>();
String[] strArr = str.split(" ");
char [] patArr = pattern.toCharArray();
if(patArr.length != strArr.length){
return false;
}
for(int i = 0; i < strArr.length; i++ ){
if( map.containsKey(patArr[i]) ){
String v = map.get(patArr[i]);
if(!v.equals(strArr[i])){
return false;
}
}
else{
if(map.containsValue(strArr[i])){
return false;
}
map.put(patArr[i] ,strArr[i] );
}
}
return true;
}
}
299. Bulls and Cows
玩猜数字游戏：你写下一个数字，让你的朋友猜数字是多少。每次你朋友猜一个数字，都要给朋友提示。提示分为bull和cow两种。对于每一位数字来说，bull是指数字一样，位置也一样。cow是指数字一样，但是位置不一样。给出你的数字和朋友猜的数字，计算bull和cow分别是多少。
这题可以使用HashMap保存出现过的数字，key是数字，value是该数字出现的次数。当然，由于数字只有0-9，也可以用一个长度为10的数组替代HashMap。第一遍循环计算bull，第二遍循环计算cow。
class Solution {
public String getHint(String secret, String guess) {
int length = secret.length();
int bull = 0;
int cow = 0;
HashMap <Character, Integer> map = new HashMap<>();
char [] secArr = secret.toCharArray();
char [] gueArr = guess.toCharArray();
for(int i = 0; i < length; i++){
if(secArr[i] == gueArr[i]){
bull ++;
}else{
map.put(secArr[i] , map.getOrDefault(secArr[i], 0) +1 );
}
}
for(int i = 0; i < length; i++){
char c = gueArr[i];
if(map.containsKey(c) && map.get(c) >= 1 && secArr[i] != c){
cow++;
map.put(c , map.get(c) -1 );
}
}
return bull+"A" +cow+"B";
}
}
336. Palindrome Pairs
给出一个没有重复字符串的数组，如果将其中任意两个字符串拼起来，可以形成一个回文串的话，那么就将这两个字符串的下标记录起来，返回所有这样的下标对。
使用HashMap存储数组，key是字符串String，value是字符串的下标。这一题的难度是hard，需要考虑多种情况。
1 . abc 和 cba 的情况。 abc+cba是回文串，cba+abc也是回文串
2 . ab 和 a 的情况。 ab+a是回文串
3 . “”空字符串的情况。空字符串加上其他任何回文串都是回文串。
对于每一个字符串的分析，我们可以根据上面的情况分开处理。最容易处理的就是空字符串，如果是空字符串，直接判断要和它拼接的字符串是否是回文串即可。
上文的情况1或者情况2，我们可以结合起来一起考虑。将一个字符串切分为左右两个部分。如果左边是回文串，那么右边反转后就可以拼成一个回文串；如果右边是回文串，那么左边反转后就可以拼成一个回文串。无论反转的是左边还是右边，都需要判断是否在hashmap里面。
class Solution {
public List<List<Integer>> palindromePairs(String[] words) {
List<List<Integer>> ans = new ArrayList<>();
HashMap<String, Integer> map = new HashMap<>();
for(int i = 0; i < words.length; i++){
map.put(words[i] , i);
}
for(int i = 0; i < words.length; i++){
String word = words[i];
//for case ""
if(word.length() == 0){
for(int k = 0; k < words.length; k++){
if(k == i) continue;
if( !isPalindrome(words[k]) ) continue;
List<Integer> t = new ArrayList<>();
t.add(i);
t.add(k);
ans.add(t);
}
}
//divide one String into 2 parts
for(int j = 0; j < word.length(); j ++){
String left = word.substring(0, j);
String right = word.substring(j, word.length());
if( isPalindrome(left) ){
String reverseRight = new StringBuffer(right).reverse().toString();
if(map.containsKey(reverseRight) && map.get(reverseRight) != i){
List<Integer> t = new ArrayList<>();
t.add(map.get(reverseRight));
t.add(i);
ans.add( t );
}
}
if(isPalindrome(right)){
String reverseLeft = new StringBuffer(left).reverse().toString();
if(map.containsKey(reverseLeft) && map.get(reverseLeft) != i){
List<Integer> t = new ArrayList<>();
t.add(i);
t.add(map.get(reverseLeft));
ans.add( t );
}
}
}
}
return ans;
}
public boolean isPalindrome(String s){
if(s.length() == 0){
return true;
}
char[] arr = s.toCharArray();
int left = 0;
int right = arr.length -1;
while(left < right ){
if(arr[left ] != arr[right]){
return false;
}
left ++;
right --;
}
return true;
}
}
347. Top K Frequent Elements
给定一个非空的数字数组，返回前K个出现次数最多的元素。
用HashMap来存储每个数字的出现的次数。然后对其进行排序。HashMap不能直接排序，需要转换成一个list。
class Solution {
public List<Integer> topKFrequent(int[] nums, int k) {
HashMap<Integer,Integer> map = new HashMap<>();
for(int n : nums){
map.put(n, map.getOrDefault(n,0) +1);
}
ArrayList<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<Integer,Integer>>(){
@Override
public int compare(Map.Entry<Integer,Integer> o1, Map.Entry<Integer,Integer> o2){
return -o1.getValue().compareTo(o2.getValue());//with -，Descending; without -, Ascending
}
});
// //travese all key-value pairs in this HashMap
// Iterator> iterator = list.iterator();
// for(Map.Entry m : list){
// System.out.println(m.getKey()+"="+m.getValue());
// }
List<Integer> ans = new ArrayList<>();
for(int i = 0; i<k ; i++){
ans.add(list.get(i).getKey());
}
return ans;
}
}
349. Intersection of Two Arrays
给出两个数组，求两个数组的交集。
可以用HashMap做，也可以用HashSet做。首先遍历数组1，将所有出现的元素放入set1；然后遍历数组2，如果元素同时也在set1中出现，那么就将元素放入set2。set2转化成数组后就是正确结果了。
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
HashSet<Integer> set1 = new HashSet<>();
HashSet<Integer> set2 = new HashSet<>();
for(int i = 0; i < nums1.length; i++){
set1.add(nums1[i]);
}
for(int j = 0; j < nums2.length; j++){
if( !set1.contains(nums2[j]) ){
continue;
}
set2.add(nums2[j]);
}
Object obj [] = set2.toArray();
int [] ans = new int [obj.length];
for(int i = 0; i < ans.length; i++){
ans[i] = (int)obj[i];
}
return ans;
}
}
350. Intersection of Two Arrays II
给出两个数组，求两个数组中的交集，不需要去除重复。
遍历一遍数组sums1，使用HashMap保存数组sums1出现的数，key是数，value是该数出现的次数。随后遍历一遍数组sums2，将所有已经在sums1中出现过的数都放入队列保存起来。对于已经放入队列的数，需要将该数字的value值减一，代表已经存储过一次了。
值得一提的是，nums1的长度越短，hashMap也越小，执行速度越快。
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(int n : nums1){
map.put(n , map.getOrDefault(n,0)+1);
}
Queue<Integer> que = new LinkedList<>();
for(int n : nums2){
int cnt = map.getOrDefault(n, 0);
if(cnt > 0){
que.add(n);
map.put(n,cnt-1);
}
}
Object[] obj = que.toArray();
int [] ans = new int [que.size()];
for(int i = 0; i< ans.length; i++){
ans[i] = (int)obj[i];
}
return ans;
}
}
355. Design Twitter
设计一个简单的Twitter系统，要求可以发送推文，关注/取消关注用户，获取最近的10条推文这些功能。
可以设计两个HashMap。
第一个HashMap用于存储用户和用户发送推文的关系，key是userId，value是这个用户发送过的推文的ArrayList。
第二个HashMap用于存储用户和该用户关注的人。key是userId，value是这个用户关注的其他用户的ArrayList。
class Twitter {
public static int order = 0;
HashMap<Integer, List<Message> > messages ;
HashMap<Integer, List<Integer> > users;
/** Initialize your data structure here. */
public Twitter() {
messages = new HashMap<>();
users = new HashMap<>();
}
/** Compose a new tweet. */
public void postTweet(int userId, int tweetId) {
Message m = new Message(order,userId,tweetId);
order++;
List<Message> list = messages.getOrDefault(userId, new ArrayList<>());
list.add(0,m);
messages.put(userId, list);
}
/** Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent. */
public List<Integer> getNewsFeed(int userId) {
List<Message> allMessages = new ArrayList<>();
List<Message> list = messages.getOrDefault(userId, new ArrayList<>());
allMessages.addAll(list);
for(int followee : users.getOrDefault(userId, new ArrayList<>())){
allMessages.addAll( messages.getOrDefault(followee, new ArrayList<>()));
}
allMessages.sort(new Compare());
List<Integer> ans = new ArrayList<>();
for(int i = 0; i <allMessages.size() && i <10 ; i++){
ans.add(allMessages.get(i).getTweetId());
}
return ans;
}
/** Follower follows a followee. If the operation is invalid, it should be a no-op. */
public void follow(int followerId, int followeeId) {
if(followerId == followeeId){
return;
}
List<Integer> list = users.getOrDefault(followerId, new ArrayList<>());
if(list.contains(followeeId)){
return;
}
list.add(followeeId);
users.put(followerId, list);
}
/** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
public void unfollow(int followerId, int followeeId) {
if(followerId == followeeId){
return;
}
if( !users.containsKey(followerId) ){
return;
}
List<Integer> list = users.get(followerId);
for(int i = 0; i <list.size(); i++){
if(list.get(i) == followeeId){
list.remove(i);
break;
}
}
}
}
/**
* Your Twitter object will be instantiated and called as such:
* Twitter obj = new Twitter();
* obj.postTweet(userId,tweetId);
* List param_2 = obj.getNewsFeed(userId);
* obj.follow(followerId,followeeId);
* obj.unfollow(followerId,followeeId);
*/
class Message{
private int order;
private int userId;
private int tweetId;
public Message(int order,int userId, int tweetId){
this.order = order;
this.userId = userId;
this.tweetId = tweetId;
}
public int getOrder(){
return order;
}
public int getUserId(){
return userId;
}
public int getTweetId(){
return tweetId;
}
}
class Compare implements Comparator<Message>{
@Override
public int compare(Message m1, Message m2){
if(m1.getOrder() < m2.getOrder()){
return 1;
}else if (m1.getOrder() == m2.getOrder()){
return 0;
}else {
return -1;
}
}
}
注：上题代码参考了【Leetcode】355. Design Twitter
380. Insert Delete GetRandom O(1)
实现一个数据结构，满足插入、删除、随机获取某个元素的平均时间复杂度都是O(1).
考虑两个数据结构：
- HashMap，插入和删除的平均复杂度满足O(1)，但是HashMap没有下标，无法随机获取某个元素
- Array List，插入和随机获取某个元素的平均复杂度是O(1)，但是删除某个元素的复杂度不是常数级别。
所以将这两个数据结构强强联手，HashMap的key存放元素的值，value存放该元素在ArrayList中的下标。就可以实现插入、删除和随机获取元素都是O(1)的平均时间复杂度了
class RandomizedSet {
HashMap<Integer, Integer> map ;
List<Integer> list;
Random rand;
/** Initialize your data structure here. */
public RandomizedSet() {
map = new HashMap();
list = new ArrayList();
rand = new Random();
}
/** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
public boolean insert(int val) {
if(map.containsKey(val)){
return false;
}
map.put(val, list.size() );
list.add(val);
return true;
}
/** Removes a value from the set. Returns true if the set contained the specified element. */
public boolean remove(int val) {
if(!map.containsKey(val)){
return false;
}
int lastElement = list.get(list.size()-1);
int index = map.get(val);
//use the last element to replace the element we want to delete
list.set(index, lastElement);
map.put(lastElement, index);
//delete the last one in list
list.remove(list.size()-1);
map.remove(val);
return true;
}
/** Get a random element from the set. */
public int getRandom() {
int randomNum = rand.nextInt(list.size());
return list.get(randomNum);
}
}
/**
* Your RandomizedSet object will be instantiated and called as such:
* RandomizedSet obj = new RandomizedSet();
* boolean param_1 = obj.insert(val);
* boolean param_2 = obj.remove(val);
* int param_3 = obj.getRandom();
*/
381. Insert Delete GetRandom O(1) - Duplicates allowed
本题和380. Insert Delete GetRandom O(1)类似，唯一的不同就是可以在这个数据结构中放入重复的元素。
仍然是HashMap 和 ArrayList 的强强联手，只不过HashMap的value变成了一个集合，是所有val在list中的下标。
class RandomizedCollection {
List<Integer> list;
HashMap<Integer, Set<Integer>> map;
Random rand;
/** Initialize your data structure here. */
public RandomizedCollection() {
list = new ArrayList();
map = new HashMap();
rand = new Random();
}
/** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
public boolean insert(int val) {
if(!map.containsKey(val)){
map.put(val, new HashSet<Integer>());
}
map.get(val).add(list.size());
list.add(val);
return map.get(val).size() == 1;
}
/** Removes a value from the collection. Returns true if the collection contained the specified element. */
public boolean remove(int val) {
if(!map.containsKey(val)){
return false;
}
//remove the val's index in map
int index = map.get(val).iterator().next();
map.get(val).remove(index);
//use the lastElement to replace val in list
int lastElement = list.get(list.size()-1);
list.set(index, lastElement);
map.get(lastElement).add(index);
//remove the last element in list and it's index in map
map.get(lastElement).remove(list.size()-1);
list.remove(list.size()-1);
if(map.get(val).size() == 0){
map.remove(val);
}
return true;
}
/** Get a random element from the collection. */
public int getRandom() {
int randomNumber = rand.nextInt(list.size());
return list.get(randomNumber);
}
}
/**
* Your RandomizedCollection object will be instantiated and called as such:
* RandomizedCollection obj = new RandomizedCollection();
* boolean param_1 = obj.insert(val);
* boolean param_2 = obj.remove(val);
* int param_3 = obj.getRandom();
*/
760. Find Anagram Mappings
给出两个长度相等的数组A和数组B， 数组B是将A中的元素随机打乱后得到的。问数组A的每一个元素在数组B中的位置。
使用HashMap存储数组B中的元素和下标。key是元素，value是下标。
class Solution {
public int[] anagramMappings(int[] A, int[] B) {
HashMap<Integer, Integer> map = new HashMap<>();
for(int i = 0; i< B.length; i++){
map.put(B[i], i);
}
int [] ans = new int [A.length];
for(int i = 0; i< A.length; i++){
ans[i] = map.get(A[i]);
}
return ans;
}
}
966. Vowel Spellchecker
元音拼写检查器，已知两个String的数组，检查第二个数组里面的单词大小写和元音是否正确，如果错了，那么就需要在第一个数组中的正确单词。如果有除了大小写和元音以外的错误，拼写检查器会返回空字符串。
使用三个HashMap，第一个存完全正确的单词，第二个存将全部字母都转换成小写字母后的单词，第三个存将所有元音字母都转换成*号的单词。
class Solution {
HashSet<String> set;
HashMap<String, String> mapC;
HashMap<String, String> mapV;
public String[] spellchecker(String[] wordlist, String[] queries) {
set = new HashSet<>();
mapC = new HashMap<>();
mapV = new HashMap<>();
String [] ans = new String[queries.length];
for(String s : wordlist){
set.add(s);
String sLow = s.toLowerCase();
mapC.putIfAbsent(sLow, s);
String sVow = makeVowel(sLow);
mapV.putIfAbsent(sVow, s);
}
for(int i = 0; i < queries.length; i++){
if(set.contains(queries[i]) ){
ans[i] = queries[i];
continue;
}
String sL = queries[i].toLowerCase();
if(mapC.containsKey(sL)){
ans[i] = mapC.get(sL);
continue;
}
String sV = makeVowel(sL);
if(mapV.containsKey(sV)){
ans[i] = mapV.get(sV);
continue;
}
ans[i] = "";
}
return ans;
}
public String makeVowel(String s){
StringBuffer sb = new StringBuffer();
for(char c : s.toCharArray()){
if(c == 'a'|| c=='e' || c=='i' || c=='o' || c =='u' ){
sb.append("*");
}else{
sb.append(c);
}
}
return sb.toString();
}
}