文章目录
- 242.有效的字母异位词
- 349. 两个数组的交集
- 202. 快乐数
- 1. 两数之和
- 454. 四数相加 II
- 383. 赎金信
- 15. 三数之和
- 18. 四数之和
242.有效的字母异位词
class Solution {
public boolean isAnagram(String s, String t) {
if(s==null || t==null || s.length()!=t.length()){
return false;
}
Map<Character, Integer> mapS=strToMap(s);
Map<Character, Integer> mapT=strToMap(t);
return mapS.equals(mapT);
}
private Map<Character, Integer> strToMap(String str){
Map<Character, Integer> map = new HashMap<>();
for(int i=0;i<str.length();i++){
char ch=str.charAt(i);
// if(map.containsKey(ch)){
// map.put(ch,map.get(ch)+1);
// }else{
// map.put(ch,1);
// }
map.put(ch, map.getOrDefault(ch,0)+1);
}
return map;
}
}
为什么用下面的代码代替 equals() 方法来判断两个 Map 的内容是否相等时，会有一个测试用例不通过？
for(Map.Entry<Character, Integer> entry:mapS.entrySet()){
Character keyS=entry.getKey();
Integer valueS=entry.getValue();
if(!mapT.containsKey(keyS) || mapT.get(keyS)!=valueS){
return false;
}
}
349. 两个数组的交集
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
if(nums1==null || nums2==null){
return null;
}
// 分别将两个数组转成Set集合，去重
Set<Integer> set1=new HashSet<>();
for(int i=0;i<nums1.length;i++){
set1.add(nums1[i]);
}
Set<Integer> set2=new HashSet<>();
for(int i=0;i<nums2.length;i++){
set2.add(nums2[i]);
}
//求set1与set2的交集，交集保存在set1中
//retainAll：保留两者都有的
set1.retainAll(set2);
int[] num=new int[set1.size()];
int j=0;
for(Integer item:set1){
num[j++]=item;
}
return num;
}
}
202. 快乐数
class Solution {
public boolean isHappy(int n) {
// 将正整数n的每一位放入List集合，升序排列
List<Integer> list = getNewList(n);
Set<List> set=new HashSet<>();
int sum=-1;
while(true){
if(set.contains(list)){
return false;
}
sum=listSum(list);
if(sum==1){
return true;
}
else{
set.add(list);
list=getNewList(sum);
}
}
}
private List<Integer> getNewList(int num){
List<Integer> list = new ArrayList<>();
while(num/10!=0){
int modRes=num%10;
list.add(modRes);
num/=10;
}
list.add(num);
Collections.sort(list);
return list;
}
private int listSum(List<Integer> list){
int sum=0;
for (Integer item : list) {
sum+=item*item;
}
return sum;
}
}
1. 两数之和
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map=new HashMap<>();
for(int i=0;i<nums.length;i++){
// 要在数组元素还未进Map集合时判断Map中是否有target-nums[i])
if(map.containsKey(target-nums[i])){
return new int[]{map.get(target-nums[i]), i};
}
//Map中，key是数组元素值，value是元素在数组中的下标
map.put(nums[i],i);
}
return null;
}
}
454. 四数相加 II
思路：将四个数组分为两组处理。
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer, Integer> map=new HashMap<>();
for(int i=0;i<nums1.length;i++){
for(int j=0;j<nums2.length;j++){
int sum = nums1[i]+nums2[j];
map.put(sum, map.getOrDefault(sum, 0)+1);
}
}
int count=0;
for(int i=0;i<nums3.length;i++){
for(int j=0;j<nums4.length;j++){
int sum = nums3[i]+nums4[j];
if(map.containsKey(-sum)){
count+=map.get(-sum);
}
}
}
return count;
}
}
383. 赎金信
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
// 将magazine中的字符以及对应出现的频率记录到Map中
Map<Character,Integer> map=new HashMap<>();
for(int i=0;i<magazine.length();i++){
map.put(magazine.charAt(i),map.getOrDefault(magazine.charAt(i),0)+1);
}
for(int i=0;i<ransomNote.length();i++){
char currentCh = ransomNote.charAt(i);
if(!map.containsKey(currentCh)){
return false;
}else{
map.put(currentCh,map.get(currentCh)-1);
if(map.get(currentCh)==0){
map.remove(currentCh);
}
}
}
return true;
}
}
15. 三数之和
用了哈希表，时间超限，据说用排序+双指针思路简单且可行，后面刷到双指针的题再完成这个方法的题解。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
// key：两个元素的和 value：所有和等于key的元素组合，以下标的形式记录
Map<Integer, List<List<Integer>>> map = new HashMap<>();
for(int i=0;i<nums.length;i++){
for(int j=i+1;j<nums.length;j++){
// 将前两个元素包装到List中
List<Integer> innerList=new ArrayList<>();
innerList.add(i);
innerList.add(j);
int key=nums[i]+nums[j];
if(!map.containsKey(key)){
List<List<Integer>> outerList=new ArrayList<>();
outerList.add(innerList);
map.put(key, outerList);
}else{
map.get(key).add(innerList);
}
}
}
Set<List<Integer>> resSet=new HashSet<>();
for(int k=0;k<nums.length;k++){
if(map.containsKey(-nums[k])){
List<List<Integer>> outerList=map.get(-nums[k]);
for(List<Integer> innerList : outerList){
if(!innerList.contains(k)){
List<Integer> innerResList=new ArrayList<>();
innerResList.add(nums[innerList.get(0)]);
innerResList.add(nums[innerList.get(1)]);
innerResList.add(nums[k]);
Collections.sort(innerResList);
resSet.add(innerResList);
}
}
}
}
return new ArrayList<>(resSet);
}
}
18. 四数之和
跟三数之和一样，也是排序+双指针，刷到双指针再做。
