改结构
1. 反转单链表
//用大小为三个节点的滑动窗口顺序扫描改指针
ListNode* reverseList(ListNode *head) {
ListNode *prev=NULL, *curr=head, *next;
while(curr!=NULL) { //扫描, 次数一共为要转的节点数
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
return prev;
}
# 以下为递归解法, 因为递归天然记住当前节点, 所以仅仅改下指针即可
def reverseList(self, head):
if head == None or head.next == None:
return head
node = self.reverseList(head.next)
head.next.next = head
head.next = None # 需要这一步
return node
2. 在第m和n闭区间内反转单链表
ListNode* reverseBetween(ListNode *head, int m, int n) {
ListNode *prev_head=new ListNode(0); prev_head->next=head; //构建超头
ListNode *prev_left=prev_head, *next_right=head;
for(int i=1; i<m; i++) prev_left=prev_left->next; //左前驱
for(int i=0; i<n; i++) next_right=next_right->next; //右后驱
//套用一般反转链表代码
ListNode *prev=next_right, *curr=prev_left->next, *next;
for(int i=m; i<=n; i++) { //这里次数为要转的节点数
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
//前面接起来
prev_left->next = prev;
return prev_head->next;
}
3. K组反转单链表
1->2->3->4->5
当 k = 2 时，应当返回: 2->1->4->3->5
当 k = 3 时，应当返回: 3->2->1->4->5
ListNode* reverseKGroup(ListNode* head, int k) {
int len = 0;
for(ListNode *p=head; p!=NULL; p=p->next) len++;
for(int i=0; i<len/k; i++)
head = reverseBetween(head, i*k+1, (i+1)*k);
return head;
}
4. 旋转单链表
输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
ListNode* rotateRight(ListNode* head, int k) {
int len=0;
for(ListNode *p=head; p!=NULL; p=p->next) len++;
k = len!=0 ? k % len : 0;
if (k==0) return head;
ListNode *slow=head, *fast=head;
while(k--) fast = fast->next;
while(fast->next!=NULL) { // 找两前驱
fast = fast->next;
slow = slow->next;
}
ListNode *new_head = slow->next;
slow->next = NULL;
fast->next = head;
return new_head;
}
5. 奇偶链表
给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。
请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。
输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL
ListNode* oddEvenList(ListNode* head) {
if(head==NULL) return NULL;
ListNode *odd=head, *even=head->next; // 双指针
ListNode *head_odd=odd, *head_even=even;
while(even!=NULL&&even->next!=NULL) {
odd->next = odd->next->next;
even->next = even->next->next;
odd = odd->next;
even = even->next;
}
odd->next = head_even;
return head_odd;
}
6. 二路有序链表归并
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode pi; // 超头
ListNode *p1=l1, *p2=l2, *p=π
while(p1 != nullptr && p2 != nullptr) {
if(p1->val < p2->val) {
p->next = p1;
p1 = p1->next;
}
else {
p->next = p2;
p2 = p2->next;
}
p = p->next;
}
p->next = p1!=nullptr?p1:p2; //剩余接起来
return pi.next;
}
7. 链表归并排序
ListNode* sortList(ListNode* head) {
// 注意跳出条件与数组归并不一样
if (head==NULL||head->next==NULL) return head;
// 从中间拆表
ListNode *slow=head, *fast=head, *pre;
while(fast!=NULL&&fast->next!=NULL) {
pre = slow;
slow = slow->next;
fast = fast->next->next;
}
pre->next = NULL;
// 归并排序
ListNode *l1 = sortList(head);
ListNode *l2 = sortList(slow);
return mergeTwoLists(l1, l2);
}
8. 链表去重
ListNode* removeDuplicateNodes(ListNode* head) {
head = sortList(head);
for(ListNode *p=head; p!=NULL; ) {
while(p->next&&(p->next->val==p->val)) {
ListNode *temp = p->next;
p->next = temp->next;
delete temp;
}
p = p->next;
}
return head;
}
递归
1. 从尾到头打印链表
class Solution {
public:
vector<int> reversePrint(ListNode* head) {
vector<int> res;
traceback(head,res);
return res;
}
void traceback(ListNode* head, vector<int> &trace) {
if(head==NULL) return;
traceback(head->next, trace);
trace.push_back(head->val);
}
};
2. 复杂链表复制
class Solution {
public:
unordered_map<Node*, Node*> map;
Node* copyRandomList(Node* head) {
if(head==NULL) return NULL;
if(map.count(head)) return map[head];
Node *node = new Node(head->val);
map[head] = node;
node->next = copyRandomList(head->next);
node->random = copyRandomList(head->random);
return node;
}
};
检测
1. 环路检测
ListNode *detectCycle(ListNode *head) {
ListNode *slow=head, *fast=head;
while(fast!=NULL && fast->next!=NULL) {
slow = slow->next;
fast = fast->next->next;
if(slow==fast) { // 存在环
fast = head; //快指针到最前面
while(slow!=fast) { //找第一个相遇点
slow = slow->next; //协同步进
fast = fast->next;
}
return slow;
}
}
return NULL;
}
2. 找到倒数k个节点的值
int kthToLast(ListNode* head, int k) {
ListNode *slow=head, *fast=head;
while(k--) fast = fast->next;
while(fast!=NULL) {
slow = slow->next;
fast = fast->next;
}
return slow->val;
}
LRU缓存机制实现
/** LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
* int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值否则返回-1
* void put(int key, int value) 如果关键字已经存在，
* 则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。
* 当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，
* 从而为新的数据值留出空间。*/
class LRUCache {
public:
LRUCache(int capacity) {
cap_ = capacity;
num_items_ = 0;
}
int get(int key) {
if(map_.count(key)) {
auto it = map_[key];
pair<int, int> item = *it;
lru_.erase(it);
lru_.push_front(item);
map_[key] = lru_.begin();
return item.second;
}
else return -1;
}
void put(int key, int value) {
if(map_.count(key)) {
auto it = map_[key];
pair<int, int> item = *it;
item.second = value;
lru_.erase(it);
lru_.push_front(item);
map_[key] = lru_.begin();
}
else {
num_items_++;
if(num_items_>cap_) {
map_.erase(lru_.back().first);
lru_.pop_back();
num_items_ = cap_;
}
lru_.push_front(pair<int, int>(key, value));
map_[key] = lru_.begin();
}
}
private:
list<pair<int, int>> lru_;
unordered_map<int, list<pair<int, int>>::iterator> map_;
int cap_, num_items_;
};
