学习内容
242.有效的字母异位词
349. 两个数组的交集
202. 快乐数
1. 两数之和
数组、map、set的使用情况
具体内容
242.有效的字母异位词
题目:给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。
注意:若 s 和 t 中每个字符出现的次数都相同,则称 s 和 t 互为字母异位词。
示例 1:
输入: s = “anagram”, t = “nagaram” 输出: true
示例 2:
输入: s = “rat”, t = “car” 输出: false
提示:
1 <= s.length, t.length <= 5 * 104
s 和 t 仅包含小写字母
做题思路
题目是判断每个字符出现的次数,可以用简单的哈希表,即数组,用来表示字符s中的每个字符出现的次数,之后再遍历数组,若是字符串t与数组出现的元素相同,就-1,进而可判断字符串s和字符串t的字符到底是不是相同
解题
class Solution {
public boolean isAnagram(String s, String t) {
//若是长度不相等,则结果直接返回false
if(s.length() != t.length()){
return false;
}
//符串只有小写字符,那么就可以定义一个数组,来记录字符串s里字符出现的次数。
//因为字符a到字符z的ASCII是26个连续的数值,所以字符a映射为下标0,相应的字符z映射为下标25。
int records[] = new int[26];
//存放字符串s的值
for(int i = 0;i < s.length;i++){
records[s.charAt(i) - 'a']++;
}
//若records中出现字符串t的字符,则-1
for(int i = 0;i < t.length;i++){
records[t.charAt(i) - 'a']--;
}
//判断records中的元素是否为0
for(int i : records){
if(i != 0){
return false;
}
}
return true;
}
}
解答代码存在的疑问
1、为什么使用数组
利用字符映射到数组上,字符a到字符z的ASCII是26个连续的数值,所以字符a映射为下标0,相应的字符z映射为下标25。再遍历字符串s的时候,只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可,并不需要记住字符a的ASCII,只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数,统计出来了
349. 两个数组的交集
给定两个数组 nums1 和 nums2 ,返回 它们的交集 。输出结果中的每个元素一定是唯一的。我们可以 不考虑输出结果的顺序 。
示例 1:
输入:nums1 = [1,2,2,1], nums2 = [2,2] 输出:[2]
示例 2:
输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出:[9,4] 解释:[4,9] 也是可通过的
提示:
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000
做题思路
由于题目要求输出结果是唯一,而由于set的读写效率是最高的,并不需要对数据进行排序,而且还不会让数据重复
解题
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
if(nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0){
return new int[0];
}
HashSet<Integer> set = new HashSet<>();
HashSet<Integer> result = new HashSet<>();
for(int i = 0;i < nums1.length;i++){
set.add(nums1[i]);
}
for(int i = 0;i < nums2.length;i++){
if(set.contains(nums2[i])){
result.add(nums2[i]);
}
}
//将结果几何转为数组
return result.stream().mapToInt(x -> x).toArray();
}
}
解答代码存在的疑问
1、为什么为空的时候是返回return new int[0]?
在代码写到for循环结束之后,对于应该返回一个什么样的值产生了分歧。在代码开始定义twoSum方法时,就已经定义返回值应该是int类型的数组,所以更合理的解释是返回return new int[0](本身的含义是长度为0的数组****),定义在此处没有实际的意义,只是为了编译器编译过程中不出错。
同时,对返回值为return null,也进行了编译,编译结果也没有报错,但是个人觉得还是应该使用return new int[0];假设一个方法返回一个数组,如果它返回null,则调用方法必须先判断是否返回null,才能对返回数组进一步处理,而如果返回空数组,则无须null引用检查。鉴于此,返回数组的方法在没有结果时通常返回空数组,而不是null,这样做对于函数调用者的处理比较方便。
2、结果集合转化为数组?
mapToInt:对原数据进行转换处理,这里用的是集合,但返回值是数组,所以要转换一下
202. 快乐数
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为:
对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和
然后重复这个过程直到这个数变为 1,也可能是无限循环 但始终变不到 1。
如果这个过程 结果为 1,那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ;不是,则返回 false 。
提示:
1 <= n <= 231
做题思路
1、先解决如何得出它每个位置上的数字的平方和
2、在判断最终结果是否为1
解题
class Solution {
public boolean isHappy(int n) {
//建立一个set对象,这样才不会求得相同的平方和而一直死循环下去
HashSet<Integer> set = new HashSet<>();
while(n != 1 && !set.contains(n)){
set.add(n);
n = total(n);
}
return n == 1;
}
//求出整数每个位置上的数字的平方和
public int total(int n){
int res = 0;
while(n > 0){
int temp = n%10;
res += temp*temp;
n = n/10;
}
return res;
}
解答代码存在的疑问
1、为什么要建立对象set
由于可能存在整数的位置上所求的平方和是相同的,为了避免死循环,利用set不存放重复元素的特点,来避免这种情况的发生
1.两数之和
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target的那两个整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1:
输入:nums = [2,7,11,15], target = 9 输出:[0,1] 解释:因为 nums[0] + nums[1] ==
9 ,返回 [0, 1] 。
示例 2:
输入:nums = [3,2,4], target = 6 输出:[1,2]
示例 3:
输入:nums = [3,3], target = 6 输出:[0,1]
提示:
2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案
做题思路
要返回两数之和为target对应的整数下标,因此可用map,key值存放整数,value存放其下标;另一个整数可用target-map现有的key值判断是否存在
解题
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map = new HashMap<>();
//创建数组存放结果
int result[] = new int[2];
for(int i = 0;i < nums.length;i++){
//求其差值 放在map中进行查找相应的值
int temp = target - nums[i];
if(map.containsKey(temp)){
result[0] = i;
result[1] = map.get(temp);
}
map.put(nums[i],i);
}
return result;
}
}
解答代码存在的疑问
1、为什么要先判断map是否存在target-nums[i]相等的值
若是先把数组的元素存进链表里,极有可能导致数组中同一个元素在答案里会重复出现
数组、map、set的使用情况
1、set
输出结果中的每个元素一定是唯一的,也就是说输出的结果的去重的, 同时可以不考虑输出结果的顺序;且哈希值比较少、特别分散、跨度非常大
2、数组
限制了大小
3、map
当需要查询一个元素是否出现过,或者一个元素是否在集合里的时候,就要第一时间想到哈希法。
复习
242.有效的字母异位词
使用简单的哈希表,即数组
class Solution {
public boolean isAnagram(String s, String t) {
//由于是用ASCII的方式 因此数组长度是26
int result[] = new int[26];
for(int i = 0;i < s.length;i++){
result[s.charAt(i) - 'a']++;
}
for(int j = 0;j < t.length;j++){
result[t.charAt(j) - 'a']--;
}
for(int count : result){
if(count != 0){
return false;
}
}
return true;
}
}
349. 两个数组的交集
逻辑复杂了
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
Map<Integer,Integer> map = new HashMap<Integer,Integer>();
if(nums1.length > nums2.length){
int result[] = new result[nums1.length];
}else{
int result[] = new int[nums2.length];
}
int j = 1;
for(int i = 0; i < nums1.length;i++){
if(map.get(nums1[i]) >= 1){
map.put(nums1[i],map.get(nums1[i])+1);
}else{
map.put(nums1[i],j);
}
}
for(int k = 0;k < nums2.length;k++){
int num = map.get(nums2[k]);
map.put(nums2[k],num--);
}
if(nums1.length > nums2.length){
for(int l = 0;l < nums1.length;l++){
if(map.get(nums1[l]) == 0){
result
}
}
}
}else{
}
}
}
为了没有重复,使用set结构
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
Set<Integer> set = new HashSet<>();
Set<Integer> set1 = new HashSet<>();
for(int i = 0 ;i < nums1.length;i++){
set.add(nums1[i]);
}
for(int j = 0;j < nums2.length;j++){
if(set.contains(nums2[j])){
set1.add(nums2[j]);
}
}
return set1.stream().mapToInt(x -> x).toArray();
}
}
202. 快乐数
完全不会
class Solution {
public boolean isHappy(int n) {
//不能有重复的数,不然会陷入死循环
Set<Integer> set = new HashSet<>();
while(n != 1 || !set.contains(n)){
set.add(n);
n = sum(n);
}
return n ==1;
}
public int sum(int n){
int res = 0;
while(n>0){
int temp = n%10;
res += temp*temp;
n = n/10;
}
return res;
}
1. 两数之和
public int[] twoSum(int[] nums, int target) {
int[] res = new int[2];
if(nums == null || nums.length == 0){
return res;
}
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < nums.length; i++){
int temp = target - nums[i];
if(map.containsKey(temp)){
res[1] = i;
res[0] = map.get(temp);
}
map.put(nums[i], i);
}
return res;
}