发布时间:2024-09-01 19:01
LeetCode: 剑指 Offer II 015. 字符串中的所有变位词
描述:
给定两个字符串 s 和 p,找到 s 中所有 p 的 变位词 的子串,返回这些子串的起始索引。不考虑答案输出的顺序。
class Solution {
public List<Integer> findAnagrams(String s, String p) {
List<Integer> res = new ArrayList<>();
int pLen = p.length();
int sLen = s.length();
if(pLen > sLen) return res;
int[] pArr = new int[26];
int[] sArr = new int[26];
for(int i = 0; i < pLen; i++) {
pArr[p.charAt(i)-'a']++;
sArr[s.charAt(i)-'a']++;
}
if(Arrays.equals(pArr,sArr)) {
res.add(0);
}
for(int i = 0; i < sLen-pLen; i++) {
sArr[s.charAt(i)-'a']--;
sArr[s.charAt(i+pLen)-'a']++;
if(Arrays.equals(pArr,sArr)) {
res.add(i+1);
}
}
return res;
}
}
LeetCode: 剑指 Offer II 025. 链表中的两数相加
描述:
给定两个 非空链表 l1和 l2 来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
Stack<Integer> A = new Stack<>();
Stack<Integer> B = new Stack<>();
while(l1 != null) {
A.push(l1.val);
l1=l1.next;
}
while(l2 != null) {
B.push(l2.val);
l2=l2.next;
}
ListNode tmp = null;
int ret = 0;
while(!A.isEmpty() || !B.isEmpty() || ret != 0) {
int a = A.isEmpty() ? 0 : A.pop();
int b = B.isEmpty() ? 0 : B.pop();
int sum = a + b + ret;
ret = (a + b + ret) / 10;
sum %= 10;
ListNode node = new ListNode(sum);
node.next = tmp;
tmp = node;
}
return tmp;
}
}
LeetCode: 剑指 Offer II 026. 重排链表
描述:
给定一个单链表 L
的头节点 head
,单链表 L
表示为:
L0 → L1 → … → Ln-1 → Ln
请将其重新排列后变为:
L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …
不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public void reorderList(ListNode head) {
if(head == null) return;
ListNode mid = getMid(head);
ListNode midNext = mid.next;
mid.next = null;
ListNode ret = head;
ListNode tmp = reverse(midNext);
while(ret != null && tmp != null) {
ListNode retNext = ret.next;
ListNode tmpNext = tmp.next;
ret.next = tmp;
tmp.next = retNext;
ret = retNext;
tmp = tmpNext;
}
}
public ListNode getMid(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while(fast.next != null && fast.next.next != null) {
slow = slow.next;
fast = fast.next.next;
}
return slow;
}
public ListNode reverse(ListNode head) {
ListNode pre = null;
ListNode cur = head;
while(cur != null) {
ListNode curNext = cur.next;
cur.next = pre;
pre = cur;
cur = curNext;
}
return pre;
}
}
LeetCode: 剑指 Offer II 030. 插入、删除和随机访问都是 O(1) 的容器
描述:
设计一个支持在平均 时间复杂度 O(1) 下,执行以下操作的数据结构:
insert(val)
:当元素 val
不存在时返回 true
,并向集合中插入该项,否则返回 false
。remove(val)
:当元素 val
存在时返回 true
,并从集合中移除该项,否则返回 false
。getRandom
:随机返回现有集合中的一项。每个元素应该有 相同的概率 被返回。
- 这里使用一个 哈希表来进行记录, key 为当前插入的值, value为插入对应的List的下标
- 这里用一个list进行插入.
- 在插入的时候, 判断哈希表中是否有这个val了, 如果有直接返回false, 如果没有就将val插入list中, 并将val以及对应的list中的下标插入map中.返回true;
- 在删除的时候, 判断哈希表中是否有这个val, 如果没有直接返回false, 如果有, 获取到这个val的下标, 将list中最后一个元素和当前下标进行交换, 然后删除list最后一个元素, 删除哈希表中对应的key值,返回true;
- 随机访问, 创建一个random,大小为当前list的大小的随机数, 随机得到这个范围内的一个数,并返回.
class RandomizedSet {
private Map<Integer,Integer> map;
private List<Integer> list;
private Random random;
/** Initialize your data structure here. */
public RandomizedSet() {
map = new HashMap();
list = new ArrayList<>();
random = new Random();
}
/** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
public boolean insert(int val) {
if(map.containsKey(val)){
return false;
}
list.add(val);
map.put(val,list.size()-1);
return true;
}
/** Removes a value from the set. Returns true if the set contained the specified element. */
public boolean remove(int val) {
if(!map.containsKey(val)){
return false;
}
int index = map.get(val);
int last = list.get(list.size()-1);
list.set(index,last);
map.put(last,index);
list.remove(list.size()-1);
map.remove(val);
return true;
}
/** Get a random element from the set. */
public int getRandom() {
return list.get(random.nextInt(list.size()));
}
}
LeetCode: 剑指 Offer II 032. 有效的变位词
描述:
给定两个字符串 s 和 t ,编写一个函数来判断它们是不是一组变位词(字母异位词)。
注意:若 s 和 t 中每个字符出现的次数都相同且字符顺序不完全相同,则称 s 和 t 互为变位词(字母异位词)。
- 首先对 字符串
s
和 字符串t
进行比较, 看是否相同, 如果相同直接返回false;- 使用数组来记录
s
中字符出现的次数, 只要出现了, 就++
- 再遍历字符串
t
, 如果字符出现了, 就--
- 遍历当前的数组, 是否有元素不为0, 不为0就表示不满足题意, 返回
false
- 遍历结束 返回
true
class Solution {
public boolean isAnagram(String s, String t) {
if(s.equals(t)) return false;
int[] arr = new int[26];
for(char ch : s.toCharArray()) {
arr[ch-'a']++;
}
for(char ch : t.toCharArray()) {
arr[ch-'a']--;
}
for(int val : arr) {
if(val != 0) return false;
}
return true;
}
}
LeetCode: 剑指 Offer II 033. 变位词组
描述:
给定一个字符串数组 strs ,将 变位词 组合在一起。 可以按任意顺序返回结果列表。
注意: 若两个字符串中每个字符出现的次数都相同,则称它们互为变位词。
- 遍历strs, 将每一个元素变成char数组进行排序
- 然后将char数组变成一个字符串, 利用哈希表, 判断当前字符串是否存在于哈希表
- 如果不存在, 就创建一个list, 将str放入进去, 然后存入map中
- 如果存在, 直接得到当前字符串对应的list, 然后将str放进去.
- 遍历结束, 将map变成ArrayList返回.
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
Map<String,List<String>> map = new HashMap<>();
for(String str : strs) {
char[] ch = str.toCharArray();
Arrays.sort(ch);
String s = new String(ch);
if(!map.containsKey(s)) {
List<String> ret = new ArrayList<>();
ret.add(str);
map.put(s,ret);
}else{
map.get(s).add(str);
}
}
return new ArrayList(map.values());
}
}