135. 分发糖果，146. LRU 缓存，148. 排序链表，每题做详细思路梳理，配套Python&Java双语代码， 2024.03.28 可通过leetcode所有测试用例。
目录
135. 分发糖果
解题思路
这个问题可以通过使用贪心算法来解决。解题的关键在于确保每个孩子都至少得到一个糖果，并且在满足相邻孩子之间的评分差异时，使用尽可能少的糖果。解题步骤如下：
-
初始化：创建一个与
ratings长度相同的数组candies，初始时每个孩子都分配 1 个糖果，即candies[i] = 1。 -
从左向右扫描：遍历
ratings数组，从第二个元素开始，比较当前孩子和前一个孩子的评分。如果当前孩子的评分高于前一个孩子，那么当前孩子的糖果数应该比前一个孩子多一个，即candies[i] = candies[i-1] + 1。 -
从右向左扫描：再次遍历
ratings数组，这次是从倒数第二个元素向第一个元素遍历。比较当前孩子和后一个孩子的评分。如果当前孩子的评分高于后一个孩子，并且当前孩子的糖果数不大于后一个孩子，那么当前孩子的糖果数应该比后一个孩子多一个，即candies[i] = max(candies[i], candies[i+1] + 1)。 -
计算总糖果数：最后，将
candies数组中的所有值相加，得到的总和就是需要准备的最少糖果数目。
完整代码
Python
class Solution:
def candy(self, ratings: List[int]) -> int:
n = len(ratings)
candies = [1] * n # Step 1: Initialize
# Step 2: Scan from left to right
for i in range(1, n):
if ratings[i] > ratings[i - 1]:
candies[i] = candies[i - 1] + 1
# Step 3: Scan from right to left
for i in range(n - 2, -1, -1):
if ratings[i] > ratings[i + 1]:
candies[i] = max(candies[i], candies[i + 1] + 1)
# Step 4: Calculate the total number of candies
return sum(candies)Java
public class Solution {
public int candy(int[] ratings) {
int n = ratings.length;
int[] candies = new int[n];
Arrays.fill(candies, 1); // Step 1: Initialize
// Step 2: Scan from left to right
for (int i = 1; i < n; i++) {
if (ratings[i] > ratings[i - 1]) {
candies[i] = candies[i - 1] + 1;
}
}
// Step 3: Scan from right to left
for (int i = n - 2; i >= 0; i--) {
if (ratings[i] > ratings[i + 1]) {
candies[i] = Math.max(candies[i], candies[i + 1] + 1);
}
}
// Step 4: Calculate the total number of candies
int totalCandies = 0;
for (int candy : candies) {
totalCandies += candy;
}
return totalCandies;
}
}
146. LRU 缓存
解题思路
-
数据结构设计：
- 定义双向链表的节点类，节点包含
key、value、prev和next四个属性。 - 定义 LRUCache 类，包含
capacity、size、cache（哈希表）和两个哨兵节点head和tail来表示双向链表的头部和尾部。
- 定义双向链表的节点类，节点包含
-
辅助函数：
addNode(Node node)：在双向链表的头部添加一个新节点。removeNode(Node node)：从链表中删除一个节点。moveToHead(Node node)：将一个存在的节点移动到双向链表的头部。popTail()：弹出双向链表尾部的节点，并返回该节点。
-
主要操作：
LRUCache(int capacity)：初始化 LRU 缓存。int get(int key)：如果关键字key存在于缓存中，则返回关键字的值，否则返回 -1。如果key存在，还需要将对应的节点移动到双向链表的头部。void put(int key, int value)：如果关键字key已经存在，则变更其数据值value并移动到双向链表的头部；如果不存在，则向缓存中插入该组key-value。如果插入操作导致关键字数量超过capacity，则需要从双向链表的尾部删除最久未使用的节点，并且在哈希表中删除对应的项。
完整代码
Python
class DLinkedNode():
def __init__(self):
self.key = 0
self.value = 0
self.prev = None
self.next = None
class LRUCache:
def _add_node(self, node):
node.prev = self.head
node.next = self.head.next
self.head.next.prev = node
self.head.next = node
def _remove_node(self, node):
prev = node.prev
new = node.next
prev.next = new
new.prev = prev
def _move_to_head(self, node):
self._remove_node(node)
self._add_node(node)
def _pop_tail(self):
res = self.tail.prev
self._remove_node(res)
return res
def __init__(self, capacity: int):
self.cache = {}
self.size = 0
self.capacity = capacity
self.head, self.tail = DLinkedNode(), DLinkedNode()
self.head.next = self.tail
self.tail.prev = self.head
def get(self, key: int) -> int:
node = self.cache.get(key, None)
if not node:
return -1
self._move_to_head(node)
return node.value
def put(self, key: int, value: int) -> None:
node = self.cache.get(key)
if not node:
newNode = DLinkedNode()
newNode.key = key
newNode.value = value
self.cache[key] = newNode
self._add_node(newNode)
self.size += 1
if self.size > self.capacity:
tail = self._pop_tail()
del self.cache[tail.key]
self.size -= 1
else:
node.value = value
self._move_to_head(node)
Java
class LRUCache {
class DLinkedNode {
int key;
int value;
DLinkedNode prev;
DLinkedNode next;
}
private void addNode(DLinkedNode node) {
node.prev = head;
node.next = head.next;
head.next.prev = node;
head.next = node;
}
private void removeNode(DLinkedNode node) {
DLinkedNode prev = node.prev;
DLinkedNode next = node.next;
prev.next = next;
next.prev = prev;
}
private void moveToHead(DLinkedNode node) {
removeNode(node);
addNode(node);
}
private DLinkedNode popTail() {
DLinkedNode res = tail.prev;
removeNode(res);
return res;
}
private HashMap<Integer, DLinkedNode> cache = new HashMap<>();
private int size;
private int capacity;
private DLinkedNode head, tail;
public LRUCache(int capacity) {
this.size = 0;
this.capacity = capacity;
head = new DLinkedNode();
tail = new DLinkedNode();
head.next = tail;
tail.prev = head;
}
public int get(int key) {
DLinkedNode node = cache.get(key);
if (node == null) return -1;
moveToHead(node);
return node.value;
}
public void put(int key, int value) {
DLinkedNode node = cache.get(key);
if (node == null) {
DLinkedNode newNode = new DLinkedNode();
newNode.key = key;
newNode.value = value;
cache.put(key, newNode);
addNode(newNode);
++size;
if (size > capacity) {
DLinkedNode tail = popTail();
cache.remove(tail.key);
--size;
}
} else {
node.value = value;
moveToHead(node);
}
}
}
148. 排序链表
解题思路
对链表进行排序可以通过多种算法来实现，其中归并排序因其稳定的 O(nlogn) 时间复杂度而广泛应用于链表排序中。链表的归并排序可以分为以下几个步骤：
-
寻找中点：使用快慢指针法找到链表的中点（慢指针每次前进一步，快指针每次前进两步，当快指针到达末尾时，慢指针即在中点）。
-
切分链表：将链表从中点处切分为两个链表，进行递归排序。
-
合并链表：将两个已排序的链表合并为一个有序链表。
完整代码
Python
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
# 如果链表为空或者只有一个节点，直接返回
if not head or not head.next:
return head
# 快慢指针找到中点
slow, fast = head, head.next
while fast and fast.next:
slow = slow.next
fast = fast.next.next
# 分割链表
mid, slow.next = slow.next, None
# 递归排序
left, right = self.sortList(head), self.sortList(mid)
# 合并两个有序链表
return self.merge(left, right)
# 合并两个有序链表的函数
def merge(self, l1: ListNode, l2: ListNode) -> ListNode:
dummy = tail = ListNode()
while l1 and l2:
if l1.val < l2.val:
tail.next, l1 = l1, l1.next
else:
tail.next, l2 = l2, l2.next
tail = tail.next
tail.next = l1 or l2
return dummy.nextJava
/**
* 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; }
* }
*/
public class Solution {
public ListNode sortList(ListNode head) {
if (head == null || head.next == null) {
return head;
}
// Step 1: 寻找中点
ListNode slow = head, fast = head.next;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
// Step 2: 切分链表
ListNode mid = slow.next;
slow.next = null;
// Step 3: 递归排序
ListNode left = sortList(head);
ListNode right = sortList(mid);
// Step 4: 合并链表
ListNode dummy = new ListNode(0);
ListNode tail = dummy;
while (left != null && right != null) {
if (left.val < right.val) {
tail.next = left;
left = left.next;
} else {
tail.next = right;
right = right.next;
}
tail = tail.next;
}
tail.next = (left != null) ? left : right;
return dummy.next;
}
}
