力扣242题：有效的字母异位词
解题思路：
找不同的题，第一想法就是哈希表，包括数组、set、map。这里用数组就行。
代码如下：
class Solution {
public boolean isAnagram(String s, String t) {
//找不同第一想法就是哈希表，包括数组、set、map
//因为s和t都是小写字母，定义一个大小为26的数组即可
int[] arr = new int[26];
//字符串转字符数组
char[] scs = s.toCharArray();
char[] tcs = t.toCharArray();
//a映射到下标，z映射到下标25,一个做加法，一个做减法
for(char sc : scs) {
arr[sc - 'a']++;
}
for(char tc : tcs) {
arr[tc - 'a']--;
}
//遍历数组，看看是否都为0？
for(int c : arr) {
if(c != 0) {
return false;
}
}
return true;
}
}
力扣349题：两个数组的交集
解题思路：
要找两个数组的交集，说明涉及到重复元素的问题，那最适合不过hashset了，因为它不能储存重复元素。这里需要2个hashset，一个用来去重，另一个用来储存结果+去重。分别遍历俩个数组。最后还有就是将hashset转成数组返回。
代码如下：
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
//定义一个hashset，因为它不能储存重复元素
Set<Integer> set = new HashSet<>();
Set<Integer> resSet = new HashSet<>();
//添加数组nums1元素到hashset中
for(int num1 : nums1) {
set.add(num1);
}
//遍历nums2，如果set中有，那就是我们要找的答案
for(int num2 : nums2) {
if(set.contains(num2)) {
resSet.add(num2);
}
}
//定义一个返回结果的数组
int[] res = new int[resSet.size()];
int index = 0;
//set 转 数组
for(int i : resSet) {
res[index++] = i;
}
return res;
}
}
力扣350题：两个数组的交集 II
解题思路：
这个题与349题不一样的部分如下===>这个考虑到了重复的元素，这样的话，我们就要统计一下每个key出现的次数了，也就是我们不能再用set了，而是需要用map解决问题。
技术理清楚之后， 我们看思路=> 为了节省空间，固定短的数组，先遍历短的数组，统计map；之后查验长的数组，如果存在，此时需要两步操作，调整数组 和 调整map。
代码如下：
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
//保证nums1永远 短于 nums2,这样我们就可以先遍历nums1了
if(nums1.length > nums2.length) {
return intersect(nums2, nums1);
}
Map<Integer, Integer> save = new HashMap<>();
for(int num1 : nums1) {
//添加数组中元素到map中。有，在原有基础上+1；没有，默认值0 + 1
save.put(num1, save.getOrDefault(num1, 0) + 1);
}
//用于返回结果的数组
int[] res = new int[nums1.length];
int index = 0;
//遍历长数组nums2
for(int num2 : nums2) {
//看看save中num2有几个
int val = save.getOrDefault(num2, 0);
if(val > 0) {
//更新数组部分
res[index++] = num2;
val--;
//更新map部分
if(val > 0) {
save.put(num2, val);
} else {
save.remove(num2);
}
}
}
//截取数组
return Arrays.copyOfRange(res, 0, index);
}
}
力扣1题：两数之和
解题思路：
因为涉及到通过查看数组中的元素来确定是否满足条件，从而返回相应元素的下标，所以用数组和Set是做不到的，所以考虑使用Map。从头开始，通过target-nums[i]来判断，具体参见代码。
代码如下：
class Solution {
public int[] twoSum(int[] nums, int target) {
//二维数组，保存结果
int[] res = new int[2];
//保存元素 和 下标
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < nums.length; i++) {
//查看map中是都有要求元素
if(map.containsKey(target - nums[i])) {
//有的话，通过key获取value作为结果的一部分
res[0] = map.get(target - nums[i]);
//此时的i也是结果的一部分
res[1] = i;
}
//没有，那就加进去
map.put(nums[i], i);
}
return res;
}
}
力扣454题：四数相加 II
解题思路：
假如有四个数组numsi(i=1,2,3,4)，我们可以先统计一下前两个数组所有 和 可能出现的结果作为key，出现的次数作为value，那么肯定要用到Map。之后，再遍历后两个数组，看看之前的Map中有没有（0-后两个数组的数之和）的结果，有的话，取出其出现的次数，也就是Map中的value值。
代码如下：
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
//用于返回结果
int res = 0;
//
Map<Integer, Integer> map = new HashMap<>();
// 遍历前两个数组，将所有可能存到map中
for(int i : nums1) {
for(int j : nums2) {
if(map.containsKey(i+j)) {
map.put(i+j, map.get(i+j) + 1);
} else {
map.put(i+j, 1);
}
}
}
// 遍历后边两个数组，看看（0 - （后两个数组之和））是否出现在map中，如果有的话，那就取出value值，累加
for(int i : nums3) {
for(int j : nums4) {
if(map.containsKey(0 - (i+j))) {
res += map.get(0 - (i+j));
}
}
}
return res;
}
}
力扣383题：赎金信
解题思路：
将两个字符串变成字符数组，把后者放入Map中，值作为key，次数作为value。然后再去前者中去查看，有的话，map的value减一，没有的话，直接返回false。
代码如下：
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
char[] ran = ransomNote.toCharArray();
char[] mag = magazine.toCharArray();
Map<Character, Integer> map = new HashMap<>();
for(char c : mag) {
if(map.containsKey(c)) {
map.put(c, map.get(c) + 1);
} else {
map.put(c, 1);
}
}
for(char c : ran) {
if(map.containsKey(c) && map.get(c) > 0) {
map.put(c, map.get(c) - 1);
} else {
return false;
}
}
return true;
}
}
不过这个题也可以用数组来做，为什么呢？因为题中说明全是小写字母组成，那长度就是26呗！不论从时间上还是从空间上要比map都要好吧，可以试试！
力扣15题：三数之和
解题思路：
通过三个指针移动来确定是否满足条件。这个题的棘手之处就在于不能有重复的元组，那我们就会涉及到去重的问题，详见代码。
代码如下：
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
//返回结果
List<List<Integer>> res = new ArrayList<>();
//排序
Arrays.sort(nums);
//
for(int i = 0; i < nums.length; i++) {
if(nums[i] > 0) {
return res;
}
//必不可少
if(i > 0 && nums[i-1] == nums[i]) {
continue;
}
int left = i + 1;
int right = nums.length - 1;
while(left < right) {
if(nums[i] + nums[left] + nums[right] > 0) {
right--;
//去重，注意和第三种情况的不同之处
while(left < right && nums[right] == nums[right+1]) {
right--;
}
} else if(nums[i] + nums[left] + nums[right] < 0) {
left++;
//去重，注意和第三种情况的不同之处
while(left < right && nums[left] == nums[left-1]) {
left++;
}
} else {
res.add(Arrays.asList(nums[i], nums[left], nums[right]));
//去重
while(left < right && nums[right] == nums[right-1]) {
right--;
}
while(left < right && nums[left] == nums[left+1]) {
left++;
}
//缩小范围
left++;
right--;
}
}
}
return res;
}
}
力扣18题：四数之和
解题思路：
类比上一个题，四数之和，那我们就用四个指针，比上一个题多一层for循环，思路一样。
代码如下：
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
//返回结果
List<List<Integer>> res = new ArrayList<>();
//排序
Arrays.sort(nums);
for(int i = 0; i < nums.length; i++) {
//去重
if(i > 0 && nums[i] == nums[i-1]) {
continue;
}
for(int j = i + 1; j < nums.length; j++) {
//去重
if(j > i + 1 && nums[j] == nums[j-1]) {
continue;
}
//下边的代码和三数之和一模一样
int left = j + 1;
int right = nums.length - 1;
while(left < right) {
if(nums[i] + nums[j] > target - (nums[left] + nums[right])) {
right--;
while(left < right && nums[right] == nums[right+1]) {
right--;
}
} else if(nums[i] + nums[j] < target - (nums[left] + nums[right])) {
left++;
while(left < right && nums[left] == nums[left-1]) {
left++;
}
} else {
res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
while(left < right && nums[left] == nums[left+1]) {
left++;
}
while(left < right && nums[right] == nums[right-1]) {
right--;
}
left++;
right--;
}
}
}
}
return res;
}
}
扫一扫
2734
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
