每日刷题记录（九）
目录
- 第一题：宝石与石头
-
- 解题思路：
- 代码实现：
- 第二题：只出现一次的数字
-
- 解题思路：
- 代码实现：
- 第三题：复制带随机指针的链表
-
- 解题思路：
- 代码实现：
- 第四题：旧键盘
-
- 解题思路：
- 代码实现：
- 第五题：前K个高频单词
-
- 解题思路：
- 代码实现：
第一题：宝石与石头
给你一个字符串 jewels 代表石头中宝石的类型，另有一个字符串 stones 代表你拥有的石头。 stones 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
字母区分大小写，因此 “a” 和 “A” 是不同类型的石头。
示例 1：
输入：jewels = “aA”, stones = “aAAbbbb”
输出：3
示例 2：
输入：jewels = “z”, stones = “ZZ”
输出：0
提示：
- 1 <= jewels.length, stones.length <= 50
- jewels 和 stones 仅由英文字母组成
- jewels 中的所有字符都是 唯一的
解题思路：
- 创建一个HashSet，将宝石字符串中的每一个字符放进去
- 遍历stones，判断每一个字符在HahSet中是否存在，若存在，则count++，循环结束后返回count
代码实现：
class Solution {
public int numJewelsInStones(String jewels, String stones) {
HashSet<Character> hashset = new HashSet<>();
for(char ch : jewels.toCharArray()) {
hashset.add(ch);
}
int count = 0;
for(char ch : stones.toCharArray()) {
if(hashset.contains(ch)) {
count++;
}
}
return count;
}
}
第二题：只出现一次的数字
给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。
示例 1 ：
输入：nums = [2,2,1]
输出：1
示例 2 ：
输入：nums = [4,1,2,1,2]
输出：4
示例 3 ：
输入：nums = [1]
输出：1
提示：
- 1 <= nums.length <= 3 * 104
- -3 * 104 <= nums[i] <= 3 * 104
- 除了某个元素只出现一次以外，其余每个元素均出现两次。
解题思路：
- 创建一个HashSet,遍历数组，若存在该元素，则删除，否则将该元素放入set
- 再遍历数组一遍，若set中包含该元素，则返回该元素
代码实现：
class Solution {
public int singleNumber(int[] nums) {
HashSet<Integer> set = new HashSet<>();
for(int num : nums) {
if(set.contains(num)) {
set.remove(num);
}else {
set.add(num);
}
}
for(int num : nums) {
if(set.contains(num)) {
return num;
}
}
return 0;
}
}
第三题：复制带随机指针的链表
给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。返回复制链表的头节点。用一个由 n 个节点组成的链表来表示输入/输出中的链表。
每个节点用一个[val,random_index] 表示：
- val：一个表示 Node.val 的整数。
- random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。
你的代码 只 接受原链表的头节点 head 作为传入参数。
示例 1：
输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
示例 2：
输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]
示例 3：
输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]
提示：
- 0 <= n <= 1000
- -104 <= Node.val <= 104
- Node.random 为 null 或指向链表中的节点。
解题思路：
- 创建一个HashMap储存每个节点和复制后的节点，形成旧节点与新节点的一一映射
- 通过map.get方法或取新节点与其下个节点的引用，然后将节点拼接起来
代码实现：
class Solution {
public Node copyRandomList(Node head) {
if(head == null) {
return null;
}
Node cur = head;
Map<Node,Node> map = new HashMap<>();
while(cur != null) {
Node node = new Node(cur.val);
map.put(cur,node);
cur = cur.next;
}
cur = head;
while(cur != null) {
map.get(cur).next = map.get(cur.next);
map.get(cur).random = map.get(cur.random);
cur = cur.next;
}
return map.get(head);
}
}
第四题：旧键盘
旧键盘上坏了几个键，于是在敲一段文字的时候，对应的字符就不会出现。现在给出应该输入的一段文字、以及实际被输入的文字，请你列出肯定坏掉的那些键。
输入描述:
输入在2行中分别给出应该输入的文字、以及实际被输入的文字。每段文字是不超过80个字符的串，由字母A-Z（包括大、小写）、数字0-9、
以及下划线“_”（代表空格）组成。题目保证2个字符串均非空。
输出描述:
按照发现顺序，在一行中输出坏掉的键。其中英文字母只输出大写，每个坏键只输出一次。题目保证至少有1个坏键。
示例1
输入 7_This_is_a_test
_hs_s_a_es
输出 7TI
解题思路：
- 将实际输入的字符串strA转为大写放入set1中
- 遍历期待输入的字符串，判断若set1和setBroken中都没有该元素，则打印该元素，并放入setBroken
代码实现：
public class Main {
public static void func(String strE,String strA) {
TreeSet<Character> set1 = new TreeSet<>();
for(char ch : strA.toUpperCase().toCharArray()) {
set1.add(ch);
}
TreeSet<Character> setBroken = new TreeSet<>();
for(char ch : strE.toUpperCase().toCharArray()) {
if(!set1.contains(ch) && !setBroken.contains(ch)) {
System.out.print(ch);
setBroken.add(ch);
}
}
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextLine()) { // 注意 while 处理多个 case
String strE = in.nextLine();
String strA = in.nextLine();
func(strE,strA);
}
}
}
第五题：前K个高频单词
给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。
返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，按字典顺序排序。
示例 1：
输入: words = [“i”, “love”, “leetcode”, “i”, “love”, “coding”], k = 2
输出: [“i”, “love”]
解析: “i” 和 “love” 为出现次数最多的两个单词，均为2次。
注意，按字母顺序 “i” 在 “love” 之前。
示例 2：
输入: [“the”, “day”, “is”, “sunny”, “the”, “the”, “the”, “sunny”, “is”,“is”], k = 4
输出: [“the”, “is”, “sunny”, “day”]
解析: “the”, “is”, “sunny” 和 “day” 是出现次数最多的四个单词，出现次数依次为 4, 3, 2 和 1 次。
注意：
- 1 <= words.length <= 500
- 1 <= words[i] <= 10
- words[i] 由小写英文字母组成。
- k的取值范围是 [1, 不同 words[i] 的数量]
解题思路：
- 把数组里的单词全部放进map中，就能得到每个单词的出现频率
- 利用优先级队列获得出现频率前k个单词
- 用顺序表接收前k个单词
代码实现：
class Solution {
public List<String> topKFrequent(String[] words, int k) {
HashMap<String, Integer> map = new HashMap<>();
for (String s : words) {
if (map.get(s) == null) {
map.put(s, 1);
}
Integer val = map.get(s);
map.put(s, val + 1);
}
PriorityQueue<Map.Entry<String, Integer>> queue = new PriorityQueue<>(k, new Comparator<Map.Entry<String, Integer>>() {
@Override
public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
if (o1.getValue().compareTo(o2.getValue()) == 0) {
return o2.getKey().compareTo(o1.getKey());
}
return o1.getValue().compareTo(o2.getValue());
}
});
for (Map.Entry<String, Integer> entry : map.entrySet()) {
if (queue.size() < k) {
queue.offer(entry);
}else {
Map.Entry<String, Integer> top = queue.peek();
if (top.getValue().compareTo(entry.getValue()) == 0) {
if (top.getKey().compareTo(entry.getKey()) > 0) {
queue.poll();
queue.offer(entry);
}
} else {
if (top.getValue().compareTo(entry.getValue()) < 0) {
queue.poll();
queue.offer(entry);
}
}
}
}
List<String> ret = new ArrayList<>();
for(int i = 0;i < k;i++) {
String s = queue.poll().getKey();
ret.add(s);
}
Collections.reverse(ret);
return ret;
}
}