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 ...
随机推荐
- 使用NHibernate（4）--拦截器和事件
如果想在一个事务的开始.执行中.完成后等过程中执行一些自己的逻辑(比如记录日志.查看sql),拦截器(Interceptors)和事件(Event)就可以发挥作用了.两者所能完成的功能差不多. 1,拦 ...
- hibernate树状映射
例如公司的组织机构:一个公司可以有多个子公司,一个子公司子有多个部门. 其实就是一张表, 例子程序: Organization类: package com.oracle.hibernate; impo ...
- SpringSecurity自定义用户登录
根据上一节的配置,默认在服务开启的时候会被要求自动的进行表单登陆.用到的用户名只能是一个固定的用户名user,它的密码是每次启动的时候服务器自动生成的.最常见的场景是我们的用户是从数据库中获取的. 1 ...
- Hive的Shell里hive> 执行操作时，出现FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask错误的解决办法（图文详解）
不多说,直接上干货! 这个问题,得非 你的hive和hbase是不是同样都是CDH版本,还是一个是apache版本,一个是CDH版本. 问题详情 [kfk@bigdata-pro01 apache-h ...
- 数据库~Mysql派生表注意的几点~关于百万数据的慢查询问题
基础概念 派生表是从SELECT语句返回的虚拟表.派生表类似于临时表,但是在SELECT语句中使用派生表比临时表简单得多,因为它不需要创建临时表的步骤. 术语:*派生表*和子查询通常可互换使用.当SE ...
- Installing Vim 8.0 on Ubuntu 16.04 and Linux Mint 18
sudo add-apt-repository ppa:jonathonf/vim sudo apt update sudo apt install vim uninstall sudo apt re ...
- How can I set ccshared=-fPIC while executing ./configure?
解决方式如下: make clean ./configure CFLAGS=-fPIC CXXFLAGS=-fPIC
- C#(winform)为button添加背景图片,并去掉各种边框
1.既然是添加背景图片 所以这里应该使用 Button.BackgroudImage = "" ;来设置图片 而不应该使用 Button.Image = "" ...
- vmware8~12最新版本 克隆Centos6.X 系列虚拟机网卡无法启动问题 （三步即可）
1.因工作或者学习需要,都需要在VM上克隆一台服务器,此时无论是快捷克隆(相当于快照的机体)或者完整克隆,都会碰到IP问题. 如:创建后症状:启动之后使用ifconfig,发现无ip地址,只有回环地址 ...
- Mavean多工程依赖项目
前言 本篇文章基于Java开发小技巧(二):自定义Maven依赖中创建的父工程project-monitor实现,运用我们自定义的依赖包进行多工程依赖项目的开发. 下面以多可执行Jar包项目的开发为例 ...