查找
1. 查找表
这一部分主要考察各种数据结构的使用:
- Set:元素互不重复,且只需要元素的值本身
- HashMap:需要键值对存储,键不重复,无序
- TreeMap:键值对存储,默认按键排序,也可自定义Comparator< E >
- PriorityQueue:优先队列,用于无序输入、有序输出,例如任务调度场景,根据重要度返回队首
1.1 两个数组的交集(一)
重复结果只需要输出一次,因此只需要两个Set取交集
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
Set<Integer> set1 = new HashSet<>();
Set<Integer> set2 = new HashSet<>();
for (int num: nums1){
set1.add(num);
}
for (int num: nums2){
set2.add(num);
}
set1.retainAll(set2);
int[] ans = new int[set1.size()];
int idx = 0;
for (int num: set1){
ans[idx++] = num;
}
return ans;
}
}
1.2 两个数组的交集(二)
重复元素输出次数以两个字符串中较小者为准,显然需要记录次数,用HashMap记录其中一个数组即可
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
Map<Integer, Integer> map1 = new HashMap<>();
// 将nums1放进字典里
for (int num: nums1){
if (map1.containsKey(num)){
map1.put(num, map1.get(num) + 1);
}else{
map1.put(num, 1);
}
}
int[] ans = new int[nums1.length];
int idx = 0;
for (int num: nums2){
if (map1.containsKey(num) && map1.get(num) > 0){
ans[idx++] = num;
map1.put(num, map1.get(num) - 1);
}
}
return Arrays.copyOf(ans, idx);
}
}
1.3 有效的字母异位词
两个字符串放进字典里,判断两个字典是否相等
class Solution {
public boolean isAnagram(String s, String t) {
Map<Character, Integer> map1 = new HashMap<>();
Map<Character, Integer> map2 = new HashMap<>();
for(int i = 0;i < s.length();i++){
char c = s.charAt(i);
if (map1.containsKey(c)){
map1.put(c, map1.get(c) + 1);
}else{
map1.put(c, 1);
}
}
for(int i = 0;i < t.length();i++){
char c = t.charAt(i);
if (map2.containsKey(c)){
map2.put(c, map2.get(c) + 1);
}else{
map2.put(c, 1);
}
}
return map1.equals(map2);
}
}
1.4 快乐数
维护一个平方和变量sum,sum = 1就跳出循环,sum每次都放入Set中,如果sum重复出现Set中已有的数字,说明陷入无穷循环。
class Solution {
public boolean isHappy(int n) {
Set<Integer> set = new HashSet<>();
while (n != 1){
int sum = 0;
while (n > 0){
int num = n % 10;
sum += num*num;
n /= 10;
}
if (set.contains(sum)){
return false;
}
set.add(sum);
n = sum;
}
return true;
}
}
1.5 单词规律
将pattern和word分别put进map中,值为i,如果两个都是第一次放,或者之前放的次数相同,put的返回值也一定相同。
class Solution {
public boolean wordPattern(String pattern, String str) {
if (pattern == null && str == null) return true;
if (pattern == null || str == null) return false;
String[] values = str.split(" ");
int n = values.length;
if (pattern.length() != n) return false;
Map<Object, Integer> map = new HashMap<>();
for (int i = 0;i < n;i++){
int x = map.put(pattern.charAt(i), i);
int y = map.put(values[i], i);
if (!Objects.equals(x, y)) return false;
}
return true;
}
}
1.6 同构字符串
class Solution {
public boolean isIsomorphic(String s, String t) {
if (s.length() == 0 && t.length() == 0) return true;
if (s.length() == 0 || t.length() == 0) return false;
char[] c1 = s.toCharArray();
char[] c2 = t.toCharArray();
Map<Character, Character> map = new HashMap<>();
for (int i = 0;i < c1.length;i++){
if (map.containsKey(c1[i])){
if (map.get(c1[i]) != c2[i]) return false;
}else if (map.containsValue(c2[i])){
return false;
}else{
map.put(c1[i], c2[i]);
}
}
return true;
}
}
1.7 根据字符出现频率排序
将给定字符串以字符为键频率为值传入一个map,再将map.entrySet()传入一个优先队列,最后不断返回队首的键值对并将键在输出字符串中重复值次。
class Solution {
public String frequencySort(String s) {
if (s.length() < 2) return s;
Map<Character, Integer> map = new HashMap<>();
for (int i = 0;i < s.length();i++){
char x = s.charAt(i);
if (map.containsKey(x)){
map.put(x, map.get(x) + 1);
}else{
map.put(x, 1);
}
}
Queue<Map.Entry<Character, Integer>> pq = new PriorityQueue<>(map.size(),
new Comparator<Map.Entry<Character, Integer>>(){
@Override
public int compare(Map.Entry<Character, Integer> e1, Map.Entry<Character, Integer> e2){
return e2.getValue().compareTo(e1.getValue());
}
});
for (Map.Entry<Character, Integer> entry: map.entrySet()){
pq.add(entry);
}
StringBuilder ans = new StringBuilder();
while(!pq.isEmpty()){
Map.Entry<Character, Integer> entry = pq.poll();
int num = entry.getValue();
char c = entry.getKey();
while(num > 0){
ans.append(c);
num--;
}
}
return ans.toString();
}
}