目录
[5.存在重复元素 II](#5.存在重复元素 II)
1.有效的字母异位词
java
class Solution {
public boolean isAnagram(String s, String t) {
//貌似字符串中的字符计算，比较即可
int [] x=counter(s),y=counter(t);
for(int i=0;i<x.length;i++){
if(x[i]!=y[i]){
return false;
}
}
return true;
}
private int [] counter(String s){
int [] ans=new int[26];
for(int i=0;i<s.length();i++){
ans[s.charAt(i)-'a']++;
}
return ans;
}
}2.字母异位词分组
java
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
//我想到一个方法，sort重排每一个字符串，然后进行分组就可以了。
//先建一个哈希表
Map<String,List<String>>m=new HashMap<>();
for(String str:strs){
char [] s=str.toCharArray();
Arrays.sort(s);
//s相同的字符串分到同一组
m.computeIfAbsent(new String(s),k->new ArrayList<>()).add(str);
}
return new ArrayList<>(m.values());
}
}3.两数之和
java
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map=new HashMap<>();
for(int i=0;i<nums.length;i++){
if(map.containsKey(target-nums[i])){
return new int[] {map.get(target-nums[i]),i};
}
map.put(nums[i],i);
}
throw new IllegalArgumentException("No two sum solution.");
}
}4.快乐数
java
class Solution {
//快乐数并不快乐
//快慢指针，相遇就不是，遇到1就是
//负责拆解
public int getNext(int n){
int totalSum=0;
while(n>0){
int d=n%10;
n=n/10;
totalSum+=d*d;
}
return totalSum;
}
//判断是不是快乐数
public boolean isHappy(int n) {
int slow=n;
int fast=getNext(n);
while(fast!=1&&slow!=fast){
//慢走1步，快走2步
slow=getNext(slow);
fast=getNext(getNext(fast));
}
return fast==1;
}
}5.存在重复元素 II
java
class Solution {
public boolean containsNearbyDuplicate(int[] nums, int k) {
//哈希表感觉能秒
Map<Integer,Integer> map=new HashMap<>();
for(int i=0;i<nums.length;i++){
if(map.containsKey(nums[i])){
if(Math.abs(i-map.get(nums[i]))<=k){
return true;
}
}
map.put(nums[i],i);
}
return false;
}
}6.最长连续序列
java
class Solution {
public int longestConsecutive(int[] nums) {
if(nums==null||nums.length==0){
return 0;
}
//对数组排序
Arrays.sort(nums);
int longest=1;
int count=1;
for(int i=1;i<nums.length;i++){
if(nums[i]!=nums[i-1]){
if(nums[i]==nums[i-1]+1){
count++;
}else{
longest=Math.max(longest,count);
count=1;
}
}
}
return Math.max(longest,count);
}
}]
java
class Solution {
public int longestConsecutive(int[] nums) {
//先排序再遍历的话复杂度会超过O(n)
//创建哈希集合
Set<Integer> num_set=new HashSet<Integer>();
for(int num:nums){
//将数组中每个整数添加到集合，去除重复元素
num_set.add(num);
}
int longest=0;
for(int num:num_set){
//如果集合不包含当前整数-1的值，说明整数困难是连续序列的起点
if(!num_set.contains(num-1)){
int cur=num;
int count=1;
//当集合包含当前数字+1的值，说明连续序列可以继续延伸
while(num_set.contains(cur+1)){
cur+=1;
count+=1;
}
longest=Math.max(longest,count);
}
}
return longest;
}
}7.汇总区间
java
class Solution {
public List<String> summaryRanges(int[] nums) {
//感觉就是一次遍历，不断更新并创建边界值即可
//双指针
List<String> ret=new ArrayList<>();
for(int i=0,j,n=nums.length;i<n;i=j+1){
j=i;
while(j+1<n&&nums[j+1]==nums[j]+1){
++j;
}
ret.add(f(nums,i,j));
}
return ret;
}
private String f(int [] nums,int i,int j){
return i==j?nums[i]+"":String.format("%d->%d",nums[i],nums[j]);
}
}8.合并区间
java
class Solution {
public int[][] merge(int[][] intervals) {
//按照第一个元素排序
Arrays.sort(intervals,(a,b)->a[0]-b[0]);
List<int[]> ret=new ArrayList<>();
for(int [] p:intervals){
//当前区间左端点<=最后一个区间右端点，可以合并
if(!ret.isEmpty()&&p[0]<=ret.get(ret.size()-1)[1]){
ret.get(ret.size()-1)[1]=Math.max(ret.get(ret.size()-1)[1],p[1]);
}else{
//不能合并，添加区间
ret.add(p);
}
}
return ret.toArray(new int[ret.size()][]);
}
}