LeetCode:242. 有效的字母异位词 - 力扣（LeetCode）
1.思路
创建一个对应26个英文字母大小的数组，对每个字母出现的频次进行录入，最后对数组进行判空，全为空则为有效字母异位词。
2.代码实现
class Solution {
public boolean isAnagram(String s, String t) {
// 创建一个长度为26的整型数组，用于记录26个字母各自出现的次数
int[] result = new int[26];
for (int i = 0; i < s.length(); i++) {
// 将字符串s中每个字母出现的次数记录到数组record中，通过将字母的ASCII码减去'a'来计算索引
result[s.charAt(i) - 'a']++;
}
for (int i = 0; i < t.length(); i++) {
result[t.charAt(i) - 'a']--; // 对t中的每个字母进行--
}
for (int count : result) {
if (count != 0) {
return false;
}
}
return true;
}
}
3.复杂度分析
时间复杂度：O(n).
空间复杂度：O(1).
LeetCode:349. 两个数组的交集 - 力扣（LeetCode）
1.思路
两层for循环遍历输出相同值的同时对其进行判重，list进行收集结果，最后将list转化为数组，输出即可。
2.代码实现
突然发现这种看起来更简单，爱了~
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < nums1.length; i++) {
for (int j = 0; j < nums2.length; j++) {
if (nums1[i] == nums2[j] && !list.contains(nums1[i])) {
list.add(nums1[i]);
}
}
}
int[] arr = new int[list.size()];
for (int i = 0; i < list.size(); i++) {
arr[i] = list.get(i);
}
return arr;
}
}
3.复杂度分析
时间复杂度：O(n^2).
空间复杂度：O(n).
LeetCode:202. 快乐数 - 力扣（LeetCode）
1.思路
借助链表临时存储数，调用方法contains()判重，对当前数循环取模判断。
2.代码实现
class Solution {
public boolean isHappy(int n) {
List<Integer> record = new ArrayList<>(); // 临时存储数，调用方法判断
while (n != 1 && !record.contains(n)) {
record.add(n);
n = getNextNumber(n);
}
return n == 1;
}
public int getNextNumber(int n) {
int res = 0; // 用于存储下一个数的变量
while (n > 0) {
int temp = n % 10;
res += temp * temp;
n = n / 10;
}
return res; // 返回下一个数
}
}
3.复杂度分析
时间复杂度：O(logn).
空间复杂度：O(logn).
LeetCode:1. 两数之和 - 力扣（LeetCode）
1.思路
① 双层for循环暴力输出即可. ②
2.代码实现
class Solution {
public int[] twoSum(int[] nums, int target) {
int[] res = new int[2];
for (int i = 0; i < nums.length; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[i] + nums[j] == target) {
res[0] = i;
res[1] = j;
break;
}
}
}
return res;
}
}
//map也很香
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++) {
int temp = target - nums[i];
if (map.containsKey(temp)) {
res[1] = i;
res[0] = map.get(temp);
break;
}
map.put(nums[i], i);
}
return res;
}
}
3.复杂度分析
针对map实现的
时间复杂度：O(n).
空间复杂度：O(1).
