leetcode Ch5-Linked List
一、
1. Remove Duplicates from Sorted List II
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
ListNode* dummy = new ListNode();
dummy->next = head;
ListNode* pre = dummy;
ListNode* cur = head;
while (cur != NULL && cur->next != NULL) {
if (cur->val == cur->next->val) {
while(cur->next != NULL && cur->val == cur->next->val) {
cur = cur->next;
}
pre->next = cur->next;
cur = cur->next;
} else {
pre = pre->next;
cur = cur->next;
}
}
return dummy->next;
}
};
2. Remove Duplicates from Sorted List
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
ListNode* dummy = new ListNode();
dummy->next = head;
ListNode* pre = dummy, *cur = head;
while (cur != NULL && cur->next != NULL) {
if (cur->val == cur->next->val) {
while (cur->next != NULL && cur->val == cur->next->val) {
cur = cur->next;
}
pre->next = cur;
pre = pre->next;
cur = cur->next;
} else {
cur = cur->next;
pre = pre->next;
}
}
return dummy->next;
}
};
只在1.的基础上改了两句。
二、
1. Reverse Linked List 【模板式】
ListNode* reverseList(ListNode* head) {
ListNode* prev = NULL;
while (head != NULL) {
ListNode* next = head->next;
head->next = prev;
prev = head;
head = next;
}
return prev;
}
while循环里和swap很像，上一句的右侧都是下一句的左侧。
class Solution {
public:
ListNode* reverseBetween(ListNode* head, int m, int n) {
ListNode* dummy = new ListNode();
dummy->next = head;
ListNode* prev = dummy;
for (int i = ; i < m; i++) {
prev = prev->next;
}
head = prev->next;
ListNode* next = head->next;
ListNode* pprev = prev;
ListNode* tail = head;
for (int i = m; i <= n; i++) { //这部分和reverseList一样
next = head->next;
head->next = prev;
prev = head;
head = next;
}
pprev->next = prev;
tail->next = head;
return dummy->next;
}
};
中间(m, n)区间内reverse和1.里reverseList一样。
注意：从m到n这几个元素都参与for循环了，包括第m个元素！进行reverse之后，head指向第n+1个元素，prev指向逆转后的新head（从m到n这几个元素中的新head）。
class Solution {
public:
ListNode* partition(ListNode* head, int x) {
ListNode* leftDummy = new ListNode();
ListNode* rightDummy = new ListNode();
ListNode* left = leftDummy, *right = rightDummy;
while (head != NULL) {
if (head->val < x) {
left->next = head;
left = left->next;
} else {
right->next = head;
right = right->next;
}
head = head->next;
}
right->next = NULL;
left->next = rightDummy->next;
return leftDummy->next;
}
};
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode* dummy = new ListNode();
ListNode* pre = dummy;
while (l1 != NULL && l2 != NULL) {
if (l1->val < l2->val) {
pre->next = l1;
l1 = l1->next;
} else {
pre->next = l2;
l2 = l2->next;
}
pre = pre->next;
}
if (l1 != NULL) {
pre->next = l1;
}
if (l2 != NULL) {
pre->next = l2;
}
return dummy->next;
}
};
用MergeSort和QuickSort分别实现一下。
MergeSort用到了findMedian的方法（利用双指针可以达到one-pass找到中点）。
class Solution {
public:
ListNode* findMiddle(ListNode* head) { // 找到的是下标为(n - 1) / 2的点（如果是偶数个数，那就是中间偏左一点的）
ListNode* slow = head, *fast = head->next;
while (fast != NULL && fast->next != NULL) {
slow = slow->next;
fast = fast->next->next;
}
return slow;
}
ListNode* merge(ListNode* l1, ListNode* l2) {
ListNode* dummy = new ListNode();
ListNode* pre = dummy;
while (l1 != NULL && l2 != NULL) {
if (l1->val < l2->val) {
pre->next = l1;
l1 = l1->next;
} else {
pre->next = l2;
l2 = l2->next;
}
pre = pre->next;
}
if (l1 != NULL) {
pre->next = l1;
}
if (l2 != NULL) {
pre->next = l2;
}
return dummy->next;
}
ListNode* sortList(ListNode* head) {
if (head == NULL || head->next == NULL) {
return head;
}
ListNode* mid = findMiddle(head);
ListNode* right = sortList(mid->next);
mid->next = NULL;
ListNode* left = sortList(head);
return merge(left, right);
}
};
其中merge即为上一题中的mergeTwoLists.
注意：findMiddle函数最开始时slow = head, fast = head->next. 通过这种方式可以保证求出来的mid是当有偶数个元素时是中间偏左一点的。
【三大链表基本操作：findMiddle，reverse，merge】
class Solution {
public:
ListNode* findMiddle(ListNode* head) {
ListNode* slow = head, *fast = head;
while (fast != NULL && fast->next != NULL) {
slow = slow->next;
fast = fast->next->next;
}
return slow;
}
ListNode* reverseList(ListNode* head) {
ListNode* prev = NULL;
while (head != NULL) {
ListNode* next = head->next;
head->next = prev;
prev = head;
head = next;
}
return prev;
}
ListNode* merge(ListNode* l1, ListNode* l2) {
ListNode* dummy = new ListNode();
ListNode* prev = dummy;
int count = ;
while (l1 != NULL && l2 != NULL) {
count++;
if (count % == ) {
prev->next = l1;
l1 = l1->next;
} else {
prev->next = l2;
l2 = l2->next;
}
prev = prev->next;
}
if (l1 != NULL) {
prev->next = l1;
} else {
prev->next = l2;
}
return dummy->next;
}
void reorderList(ListNode* head) {
if (head == NULL || head->next == NULL) {
return;
}
ListNode* mid = findMiddle(head);
ListNode* p = reverseList(mid->next);
mid->next = NULL;
merge(head, p);
}
};
方法1： 利用堆（priority_queue）。每次取出K个队列中的最小值（logK），共取N次，因此复杂度为 NlogK
class Solution {
public:
struct cmp {
bool operator()(ListNode* p, ListNode* q) {
return p->val > q->val;
}
};
ListNode* mergeKLists(vector<ListNode*> &lists) {
if (lists.empty()) {
return NULL;
}
priority_queue<ListNode*, vector<ListNode*>, cmp> pq;
ListNode* dummy = new ListNode();
ListNode* prev = dummy;
for (int i = ; i < lists.size(); i++) {
if (lists[i] != NULL) {
pq.push(lists[i]);
}
}
while (!pq.empty()) {
ListNode* tmp = pq.top();
prev->next = tmp;
prev = tmp;
pq.pop();
if (tmp->next != NULL) {
pq.push(tmp->next);
}
}
return dummy->next;
}
};
方法2：分治。【自顶向下】
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*> &lists) {
if (lists.empty()) {
return NULL;
}
return mergeHelper(lists, , lists.size() - );
}
ListNode* mergeHelper(vector<ListNode*> &lists, int start, int end) {
if (start == end) {
return lists[start];
}
int mid = start + (end - start) / ;
ListNode* left = mergeHelper(lists, start, mid);
ListNode* right = mergeHelper(lists, mid + , end);
return mergeTwoLists(left, right);
}
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode* dummy = new ListNode();
ListNode* prev = dummy;
while (l1 != NULL && l2 != NULL) {
if (l1->val < l2->val) {
prev->next = l1;
l1 = l1->next;
} else {
prev->next = l2;
l2 = l2->next;
}
prev = prev->next;
}
if (l1 != NULL) {
prev->next = l1;
} else {
prev->next = l2;
}
return dummy->next;
}
};
注意：不要忘了判空！这种边界条件要谨慎！谨记！
class Solution {
public:
bool hasCycle(ListNode* head) {
if (head == NULL) {
return false;
}
ListNode* slow = head, *fast = head;
while (fast && fast->next) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) {
return true;
}
}
return false;
}
};
class Solution {
public:
ListNode* detectCycle(ListNode* head) {
ListNode* slow = head, *fast = head;
while (fast && fast->next) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) {
while (head != slow) {
head = head->next;
slow = slow->next;
}
return slow;
}
}
return NULL;
}
};
class Solution {
public:
void copyNext(RandomListNode* head) {
RandomListNode* pre = head;
while (pre != NULL) {
RandomListNode* tmp = new RandomListNode(pre->label);
tmp->next = pre->next;
pre->next = tmp;
pre = pre->next->next;
}
}
void copyRandom(RandomListNode* head) {
RandomListNode* pre = head;
while (pre != NULL) {
if (pre->random != NULL) { // don't forget
pre->next->random = pre->random->next;
}
pre = pre->next->next;
}
}
RandomListNode* splitList(RandomListNode* head) {
RandomListNode* newHead = head->next;
RandomListNode* q = newHead;
while (head != NULL) {
head->next = q->next;
head = head->next;
if (head) { // don't forget
q->next = head->next;
}
q = q->next;
}
return newHead;
}
RandomListNode* copyRandomList(RandomListNode* head) {
if (head == NULL) {
return NULL;
}
copyNext(head);
copyRandom(head);
return splitList(head);
}
};
注意！处理链表题很重要的一点是：在对一个指针p取next时，首先要确保 p!=NULL
Convert Sorted List to Binary Search Tree
Convert Binary Tree to Doubly Linked List
Heapify 堆化
=================================================
| 24 | Swap Nodes in Pairs | 32.4% | Medium | |
| 148 | 22.2% | Medium | ||
| 61 | Rotate List | 21.7% | Medium | |
| 25 | 25.4% | Hard | ||
| 206 | 31.9% | Easy | ||
| 92 | 26.0% | Medium | ||
| 143 | 21.0% | Medium | ||
| 19 | Remove Nth Node From End of List | 27.0% | Easy | |
| 203 | Remove Linked List Elements | 25.9% | Easy | |
| 83 | 34.5% | Easy | ||
| 82 | 25.0% | Medium | ||
| 86 | 27.4% | Medium | ||
| 234 | Palindrome Linked List | 22.6% | Easy | |
| 21 | 32.6% | Easy | ||
| 23 | 21.1% | Hard | ||
| 141 | 36.3% | Medium | ||
| 142 | 31.4% | Medium | ||
| 160 | Intersection of Two Linked Lists | 28.7% | Easy | |
| 147 | Insertion Sort List | 26.6% | Medium | |
| 237 | Delete Node in a Linked List | 46.7% | Easy | |
| 138 | 25.2% | Hard | ||
| 109 | 27.9% | Medium | ||
| 2 | Add Two Numbers | 20.7% | Medium |
[剑指offer] 两个链表的第一个公共节点
class Solution {
public:
ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2) {
ListNode* p = pHead1;
int count1 = , count2 = ;
while (p != NULL) {
count1++;
p = p->next;
}
p = pHead2;
while (p != NULL) {
count2++;
p = p->next;
}
if (count1 < count2) {
return findNode(pHead1, count1, pHead2, count2);
} else {
return findNode(pHead2, count2, pHead1, count1);
}
}
ListNode* findNode(ListNode* pHead1, int count1, ListNode* pHead2, int count2) {
if (pHead1 == NULL) {
return NULL;
}
int tmp = count2 - count1;
ListNode* p2 = pHead2, *p1 = pHead1;
while (tmp--) {
p2 = p2->next;
}
while (p1 != NULL && p1 != p2) {
p1 = p1->next;
p2 = p2->next;
}
return p1;
}
};
参考剑指offer P193. 本题说的“公共节点”不是指“值相等”，而是“同一个节点”。即两链表在该点处汇合。
leetcode Ch5-Linked List的更多相关文章
- 【Leetcode】Linked List Cycle II
Given a linked list, return the node where the cycle begins. If there is no cycle, return null. Foll ...
- [LeetCode] 141. Linked List Cycle 链表中的环
Given a linked list, determine if it has a cycle in it. Follow up:Can you solve it without using ext ...
- [LeetCode] 142. Linked List Cycle II 链表中的环 II
Given a linked list, return the node where the cycle begins. If there is no cycle, return null. Foll ...
- [LeetCode] Palindrome Linked List 回文链表
Given a singly linked list, determine if it is a palindrome. Follow up: Could you do it in O(n) time ...
- [LeetCode] Reverse Linked List 倒置链表
Reverse a singly linked list. click to show more hints. Hint: A linked list can be reversed either i ...
- [LeetCode] Remove Linked List Elements 移除链表元素
Remove all elements from a linked list of integers that have value val. Example Given: 1 --> 2 -- ...
- [LeetCode] Reverse Linked List II 倒置链表之二
Reverse a linked list from position m to n. Do it in-place and in one-pass. For example:Given 1-> ...
- Java for LeetCode 142 Linked List Cycle II
Given a linked list, return the node where the cycle begins. If there is no cycle, return null. Foll ...
- [LeetCode] Split Linked List in Parts 拆分链表成部分
Given a (singly) linked list with head node root, write a function to split the linked list into k c ...
- [LeetCode] Design Linked List 设计链表
Design your implementation of the linked list. You can choose to use the singly linked list or the d ...
随机推荐
- （转）我是如何在SQLServer中处理每天四亿三千万记录的
首先声明,我只是个程序员,不是专业的DBA,以下这篇文章是从一个问题的解决过程去写的,而不是一开始就给大家一个正确的结果,如果文中有不对的地方,请各位数据库大牛给予指正,以便我能够更好的处理此次业务. ...
- DB2 体系结构 （进程模型）
DB2 是众多关系型数据库中的一种, 关系型数据库还包括比较火的Oracle,MySQL 实例 数据库 DB2 进程模型 DB2 通过 db2start 命令启动数据库实例,即启动相应的进程和线程,并 ...
- Scanner类中的nextToken()方法解读
下面看一下nextToken()方法的源码实现. 1.Java中的控制字符 case ' ': // (Spec 3.6) case '\t': // (Spec 3.6) case FF: // ( ...
- nginx安装及其配置详细教程
1 nginx 介绍 1 什么是nginx Nginx是一款高性能的http 服务器/反向代理服务器及电子邮件(IMAP/POP3)代理服务器. 由俄罗斯的程序设计师Igor Sysoev所开发,官方 ...
- TCP网络参数优化
TCP连接的状态 TCP连接过程是状态的转换,促使状态发生转换的因素包括用户调用.特定数据包以及超时等,具体状态如下所示: CLOSED:初始状态,表示没有任何连接. LISTEN:Server端的某 ...
- WPF中Popup等弹窗的位置不对(偏左或者偏右)
1.情况如图: 正常情况: 部分特殊情况: 在一般的电脑都能正确显示,就是第一种情况,同样的代码为什么在不同的电脑就会显示不同的位置呢,原来Windows为了满足 不同需求的用户,左撇 ...
- spring cloud连载第二篇之Spring Cloud Config
Spring Cloud Config Spring Cloud Config为分布式服务提供了服务侧和客户侧的外部配置支持.通过Spring Cloud Config你可以有一个统一的地方来管理所有 ...
- Nginx Open File Cache
Nginx 的 open_file_cache 相关配置可以缓存静态文件的元信息,在这些静态文件被频繁访问时可以显着提升性能. 被缓存的文件元信息包括: fd,文件被打开一次后,fd保留使用 size ...
- [转]EntityFramework Core技术线路（EF7已经更名为EF Core，并于2016年6月底发布）
本文转自:http://www.cnblogs.com/VolcanoCloud/p/5572408.html 官方文档英文地址:https://github.com/aspnet/EntityFra ...
- OpenFileDialog 打开文件对话框
InitialDirectory 对话框的初始目录 Filter 要在对话框中显示的文件筛选器,例如,"文本文件(*.txt)|*.txt|所有文件(*.*)||*.*" Filt ...