简单题目
141 判断一个链表是否有环 使用快慢指针
class Solution {
public:
bool hasCycle(ListNode *head) {
ListNode* pFast=head;
ListNode* pSlow=head;
if(head==NULL) return false;
while(pFast!=NULL)
{
pSlow=pSlow->next;
pFast=pFast->next;
if(pFast==NULL) return false;
pFast=pFast->next;
if(pFast==NULL) return false;
if(pFast==pSlow) return true;
}
}
};237 删除链表中的指定节点
给定链表中的一个节点，将这个节点删除。单链表的特点是：不能找到前驱结点，本题的方法是，将下一个节点的值复制到当前节点，然后跳过下一个节点。
class Solution {
public:
void deleteNode(ListNode* node) {
if (node==NULL) return;
else
{
node->val=node->next->val;
node->next=node->next->next;
}
}
}; 83.在排序链表中删除重复的节点
Given
Given
1->1->2
, return
1->2
.
Given
1->1->2->3->3
, return
1->2->3
.
方法1：使用一个循环，循环判断cur->next,之前需要判断head是否为空
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
ListNode* cur=head;
if(head==NULL) return head;
while(cur->next)
{
if(cur->next->val==cur->val)
cur->next=cur->next->next;
else
cur=cur->next;
}
return head;
}
};
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
ListNode* cur=head;
while(cur)
{
while(cur->next&&cur->next->val==cur->val)
cur->next=cur->next->next;
cur=cur->next;
}
return head;
}
};
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
if(head==NULL||head->next==NULL) return head;
head->next=deleteDuplicates(head->next);
return head->val==head->next->val?head->next:head;
}
}; 160. Intersection of Two Linked Lists 找到两个链表的公共节点
A: a1 → a2
↘
c1 → c2 → c3
↗
B: b1 → b2 → b3
方法1：先求两个链表的长度，然后让唱的指针先走掉长出的部分，最后两个链表一起走指针。时间复杂度为O（m+n），空间复杂度是1。
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
if(headA==NULL||headB==NULL) return NULL;
unsigned int lengthA=getLength(headA);
unsigned int lengthB=getLength(headB);
ListNode *pA=headA,*pB=headB;
if(lengthA<lengthB)
{
int clap=lengthB-lengthA;
while(clap!=0){
headB=headB->next;
clap--;}
}
else {
int clap=lengthA-lengthB;
while(clap!=0){
headA=headA->next;
clap--;}
}
while(headA!=headB&&headA!=NULL&&headB!=NULL)
{
headA=headA->next;
headB=headB->next;
}
return headA;
}
unsigned int getLength(ListNode* pcurrent)//长度计算函数
{
ListNode* p=pcurrent;
unsigned int length=0;
while(p!=nullptr)
{
++length;
p=p->next;
}
return length;
}
}; 206 翻转链表
方法一：自己想的，初级想法
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {//注意处理开头部分和特殊情况
if(head==NULL||head->next==NULL) return head;
ListNode* pNext=head->next;
if(pNext->next==NULL) {
pNext->next=head;
head->next=NULL;
return pNext;
}
ListNode* pNextNext=pNext->next;
head->next=NULL;
pNext->next=head;
while(pNextNext!=NULL)
{
ListNode* pTemp=pNextNext->next;
pNextNext->next=pNext;
pNext=pNextNext;
pNextNext=pTemp;
}
return pNext;
}
};class Solution {
public:
ListNode* reverseList(ListNode* head) {
//使用pre零头结点和cur原来的头结点处理链表,这个程序全程pre和cur都没有变，变的是他们指向的子节点
ListNode* pre=new ListNode(0);//新建零表头
pre->next=head;
ListNode* cur=head;
while(cur&&cur->next)
{
ListNode* temp=pre->next;//用一个指针存储需要被指向的父节点
pre->next=cur->next;//pre指向原来的子节点
cur->next=cur->next->next;//cur指向子节点的下一个节点，可能是空的
pre->next->next=temp;//将子节点的下一个节点指向存储好的父节点位置temp，这里不能指向cur，因为cur保存的永远是原来的第一个头结点
}
//当cur头指向的下一个子节点是空节点时
return pre->next;
}
};方法3：使用三个指针，循环操作，pre是当前节点的前一个节点，如果当前节点时头结点，pre预设为NULL，head是当前节点，next是head的下一个节点
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* pre=NULL;
while(head){
ListNode* next=head->next;
head->next=pre;
pre=head;
head=next;
}
return pre;
}
};class Solution {
public:
ListNode* reverseList(ListNode* head) {
if(head==NULL||head->next==NULL) return head;//考虑head是空的情况，这句目的是找到最后一个节点
ListNode* cur=reverseList(head->next);
//递归的根节点时，cur得到的是当前head的子节点
head->next->next=head;
head->next=NULL;
return cur;//cur保存最后的尾节点
}
};234 Palindrome Linked List 回文链表
自己想的方法，结果不对
class Solution {
public:
bool isPalindrome(ListNode* head) {
//自己想的方法，使用递归的形式，参照206中的递归方法
ListNode* pCur=head;
return comP(head,pCur,0);
}
bool comP(ListNode* head,ListNode* pCur,int count){
if(pCur==NULL||pCur->next==NULL) {
length=count;
return true;
}
count++;
bool tempdecide=comP(head,pCur->next,count);
if(tempdecide==false) return false;
count--;
if(count*2<length) return tempdecide;
if(head->val==pCur->next->val){
head=head->next;
return true;
}
else return false;
}
private:
int length;
};
（1）使用快慢指针，让快指针指向最后一个节点，慢指针指向中间位置；
（2）对慢指针进行操作，慢指针之后的链表做翻转操作（第206道题）；
（3）相当于将原来的指针分成两个指针，然后依次比较两个指针每个值的大小，开始的链表从原来的头部比较
（4）比较的时候，当后面的链表结束的时候，比较结束，当原链表长度是奇数时，前面的链表最后一个节点不参与比较；
class Solution {
public:
bool isPalindrome(ListNode* head) {
if(head==NULL||head->next==NULL) return true;
ListNode* slow=head;
ListNode* fast=head;
//让快指针运动到最后，这时如果是偶数个，慢指针指向中间偏左的节点，如果是奇数个，慢指针指向中间的节点
while(fast->next&&fast->next->next)
{
slow=slow->next;
fast=fast->next->next;
}
slow->next=reverseList(slow->next);
slow=slow->next;
while(slow){
if(slow->val!=head->val) return false;
slow=slow->next;
head=head->next;
}
return true;
}
//翻转链表，使用206第三种方法
ListNode* reverseList(ListNode* head){
ListNode* pre=NULL;
ListNode* next=NULL;
while(head){
next=head->next;
head->next=pre;
pre=head;
head=next;
}
return pre;
}
};
方法3：递归调用，递归函数的返回值是布尔型，每次判断的结果是回调的结果与当前比较的与。注意，在类中定义一个指针用于保存初始头结点，相当于全局变量。
class Solution {
public:
ListNode* temp;
bool isPalindrome(ListNode* head) {
if(head==NULL) return true;
temp=head;
return check(head);
}
bool check(ListNode* head){
if(head==NULL) return true;
bool tempcheck=check(head->next)&(temp->val==head->val);
temp=temp->next;
return tempcheck;
}
};21 合并两个排序链表 merge two linked list
方法1：自己写的方法，
（1）设置一个头指针，开始时指向较小的那个节点
（2）然后进入循环，每次指向较小的节点，并且被并入的节点对应的链表后移一个。
（3）要注意两个链表不一样长的时候，在结尾需要做处理。
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if(l1==NULL) return l2;
if(l2==NULL) return l1;
ListNode* prehead=new ListNode(0);
if(l1->val<l2->val)
{
prehead->next=l1;
l1=l1->next;
}
else
{
prehead->next=l2;
l2=l2->next;
}
ListNode* temp=prehead->next;
while(l1&&l2){
if(l1->val<l2->val)
{
temp->next=l1;
l1=l1->next;
}
else
{
temp->next=l2;
l2=l2->next;
}
temp=temp->next;
}
if(l1==NULL)
temp->next=l2;
else
temp->next=l1;
return prehead->next;
}
};方法2：递归方法
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if(l1==NULL) return l2;
if(l2==NULL) return l1;
if(l1->val<l2->val)
{
l1->next=mergeTwoLists(l1->next,l2);
return l1;
}
else
{
l2->next=mergeTwoLists(l2->next,l1);
return l2;
}
}
};方法1的改进版本。
一方面，可以把开始的部分合并，方法是做一个头指针的拷贝，开始关于是否有空指针的判断也可以省略不写。另一个方面，最后的判断可以使用条件语句快速写出。
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode* prehead=new ListNode(0);
ListNode* head=prehead;
while(l1&&l2){
if(l1->val<l2->val)
{
prehead->next=l1;
l1=l1->next;
}
else
{
prehead->next=l2;
l2=l2->next;
}
prehead=prehead->next;
}
prehead->next=l1?l1:l2;
return head->next;
}
};中等难度
61 Rotate List
描述：给定一个链表，在链表的倒数第k个位置旋转链表
Given 1->2->3->4->5->NULL and k = 2,
return 4->5->1->2->3->NULL.
方法：先让一个指针移动k-1步，然后和另外一个头指针一起移动，当最前面的指针移动到末尾时，后面的指针正好移动到旋转位置；
注意要保存后一个指针的前一个指针，还要保存头指针。
自己写的：出现很多的调试错误
class Solution {
public:
ListNode* rotateRight(ListNode* head, int k) {
if(head==NULL||k<=0) return head;
ListNode* frontNode=head;
//如果k的值大于链表长度怎么办？
--k;
while(k&&frontNode!=NULL)
{
frontNode=frontNode->next;
k--;
}
if(frontNode==NULL) return head;
ListNode* backNode=head;
ListNode* tempNode=head;
while(frontNode->next){
frontNode=frontNode->next;
tempNode=backNode;
backNode=backNode->next;
}
if(backNode==head) return head;
frontNode->next=head;
tempNode->next=NULL;
return backNode;
}
};class Solution {
public:
ListNode* rotateRight(ListNode* head, int k) {
if(!head) return NULL;
int length=1;
ListNode* tail=head;
while(tail->next){
tail=tail->next;
length++;
}
tail->next=head;//变成环状链表
if(k%=length)//对移动k数取余数
{
for(auto i=0;i<length-k;i++) tail=tail->next;//让tail从尾节点移动到旋转节点的前一个节点
}
ListNode* newHead=tail->next;
tail->next=NULL;
return newHead;
}
};143 recorder List
Given a singly linked list L: L0?L1?…?Ln-1?Ln,
reorder it to: L0?Ln?L1?Ln-1?L2?Ln-2?…
You must do this in-place without altering the nodes' values.
For example,
Given {1,2,3,4}, reorder it to {1,4,2,3}.
交叉更改链表顺序，但是不能直接改变数值
我的思路：使用快慢指针，将后半段链表翻转,使用前面回文串的思路，然后与第一个链表交叉起来。
这个思路与标准思路一致
class Solution {
public:
void reorderList(ListNode* head) {
if(head==NULL) return ;
ListNode* fast=head;
ListNode* slow=head;
while(fast->next&&fast->next->next){//注意判断条件，需要后面两个子节点都判断
fast=fast->next->next;
slow=slow->next;
}
//操作slow指针后面的链表，将其翻转
slow->next=reverseNode(slow->next);
//将链表截断，slow指向空，然后新的slow指向后面的翻转链表
ListNode* tail=slow;
slow=slow->next;
tail->next=NULL;
//下面将两个链表合并到一起，注意末尾操作的特殊性
ListNode* newHead=head;
while(slow)//注意判断条件决定最后末尾的操作，head的长度可能比slow多一位
{
ListNode* next1=head->next;
ListNode* next2=slow->next;
head->next=slow;
slow->next=next1;
slow=next2;
head=next1;
}
return ;
}
//翻转链表的函数
ListNode* reverseNode(ListNode* head){
//使用pre、head、next三个指针
ListNode* pre=NULL;
ListNode* next=NULL;
while(head)//注意这里的判断条件，决定末尾的情况。一定不能出现空指针next操作
{
next=head->next;
head->next=pre;
pre=head;
head=next;
}
return pre;
}
};142Linked List Cycle II 环状链表2
给定一个链表，返回链表环开始的节点，如果没有环，返回null。
分析：http://blog.csdn.net/wuzhekai1985/article/details/6725263
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
if(head==NULL) return head;
ListNode* fast=head;
ListNode* last=head;
while(fast->next&&fast->next->next)//注意需要先判断fast->next，因为必须满足这一点才能继续往下判断
{
last=last->next;
fast=fast->next->next;
if(last==fast) break;
}
if(fast->next==NULL||fast->next->next==NULL) return NULL;
while(true){
if(head==last) break;
head=head->next;
last=last->next;
}
return head;
}
};138Copy List with Random Pointer26.3%Medium
给出的链表在正常链表的基础上，每个节点还有一个随机指针指向此链表的一个节点，题目要求返回这个链表的一个拷贝
拷贝需要新建节点，难点在于怎么处理各节点之间的随机关系
思路：
（1）在原链表每个节点后面插入一个链表，并拷贝相应的值
（2）随机指针的处理，只要将新节点的随即指针指向它前面节点随机指针的下一个即可
（3）最后将链表拆解开
class Solution {
public:
RandomListNode *copyRandomList(RandomListNode *head) {
if(head==NULL) return NULL;
RandomListNode* headCopy=head;//复制原来的头结点
//第一步，在每个节点后面复制一个相同数值的节点
while(head){
RandomListNode* newNode=new RandomListNode(head->label);
RandomListNode* next=head->next;
head->next=newNode;
newNode->next=next;
head=next;
}
//第二步，处理随机指针，将每个新节点的random指针指向，它前面节点random指针指向的下一个节点
RandomListNode* newHead=headCopy->next;
RandomListNode* headCopyCopy=headCopy;
while(headCopy){
newHead->random=headCopy->random?headCopy->random->next:NULL;//注意random不一定指向一个节点，有可能是空值
headCopy=headCopy->next->next;
if(headCopy==NULL) break;
newHead=newHead->next->next;//当到达尾部时，newHead处于结尾，这个语句将产生错误，所以需要在前面退出程序
}
//第三步，分解现在的链表
headCopy=headCopyCopy;
newHead=headCopy->next;
while(headCopy&&headCopy->next&&headCopy->next->next){
RandomListNode* middle=headCopy->next;
RandomListNode* last=middle->next;
headCopy->next=last;
headCopy=middle;
}
headCopy->next=NULL;
return newHead;
}
};https://www.nowcoder.com/practice/f836b2c43afc4b35ad6adc41ec941dba?tpId=13&tqId=11178&tPage=2&rp=2&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking 这是牛客网上自己写的另外一个版本
92Reverse Linked List II 倒置链表 2
206的增进版本，截取链表的m到n的部分，翻转链表，在原来位置上改动，不允许额外的空间，要求一次完成
例如：
Given 1->2->3->4->5->NULL, m = 2 and n = 4,
return 1->4->3->2->5->NULL.
Note:
Given m, n satisfy the following condition:
1 ≤ m ≤ n ≤ length of list.
自己的思路：与前面的206没有太大的区别，需要注意的几点是：
（1）应该设置表头指针，这样能处理第一个节点就参与旋转的情况；
（2）注意要设置多个指针保存中间段的入口和出口一共四个节点；
（3）m和n相等的情况是特殊的，在程序开始时直接处理。
class Solution {
public:
ListNode* reverseBetween(ListNode* head, int m, int n) {
if(head==NULL||m==n) return head;
ListNode* preHead=new ListNode(-1);//表头指针
ListNode* result=preHead;
preHead->next=head;//表头指针指向原来的头结点，这能解决开始头结点就需要旋转的情况
ListNode* frontEntry=NULL;//保存入口之前的节点
//需要表头指针
for(int i=0;i<m;i++)
{
frontEntry=preHead;
preHead=preHead->next;
}
//下面旋转节点，采用三节点法，三个指针依次是preNode、preHead、next
ListNode* preNode=NULL;
ListNode* frontNode=preHead;//保存入口节点
for(int i=0;i<n-m+1;i++){
ListNode* next=preHead->next;
preHead->next=preNode;
preNode=preHead;//注意
preHead=next;//注意这两行的顺序
}
//此时preNode指向出口节点，preHead指向出口节点的下一个节点
frontEntry->next=preNode;//原来的入口指向中间新的头部
frontNode->next=preHead;//中间新段的尾部指向后来剩余的头部
return result->next;
}
};19Remove Nth Node From End of List33.3%Medium
将一个链表的倒数第n个节点去除，返回链表的头结点
Given linked list: 1->2->3->4->5, and n = 2.
After removing the second node from the end, the linked list becomes 1->2->3->5.
主要的难点是删除的点是第一个时怎么操作，采取的办法是认为的定义一个头结点指向原来的头结点。
方法1，代码如下：
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
//如果移除的是第一个节点，呵呵
//考虑这种特殊的情况，需要定义一个头结点指向原来的头结点，这样就能解决删除第一个节点的情况了
ListNode* newHead=new ListNode(0);
newHead->next=head;
ListNode * fast =newHead,* slow=newHead;
for(int i=0;i<n;i++)
fast=fast->next;
while(fast->next)
{
slow=slow->next;
fast=fast->next;
}
ListNode* toBeDelete=slow->next;
slow->next=slow->next->next;
delete toBeDelete;
return newHead->next;
}
};
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
//如果移除的是第一个节点，呵呵
//考虑这种特殊的情况，需要定义一个头结点指向原来的头结点，这样就能解决删除第一个节点的情况了
ListNode* newHead=new ListNode(0);
newHead->next=head;
ListNode * fast =newHead,* slow=newHead;
for(int i=0;i<n;i++)
fast=fast->next;
while(fast->next)
{
slow=slow->next;
fast=fast->next;
}
ListNode* toBeDelete=slow->next;
slow->next=slow->next->next;
delete toBeDelete;
return newHead->next;
}
};2 Add Two Numbers 27.6%Medium
描述：两个链表存储每一位数，求加和的新链表
要求：争取一次遍历成功
自己的代码：有错崩溃
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
//注意两个链表的长度可能不一样长
int addNumber=0;
ListNode* cl1=l1,* cl2=l2,* tempNode=l1;
while(cl1&&cl2)
{
int temp=cl1->val+cl2->val+addNumber;
if(temp>9){
addNumber=1;
cl1->val=temp-10;
}
else{
addNumber=0;
cl1->val=temp;
}
tempNode=cl1;
cl1=cl1->next;
cl2=cl2->next;
}
if(cl1==NULL&&cl2!=NULL)
{
tempNode->next=cl2;
}
while(tempNode)
{
int temp=tempNode->val+addNumber;//有错
if(temp>9){
addNumber=1;
tempNode->val=temp-10;
}
else{
addNumber=0;
tempNode->val=temp;
}
cl1=tempNode;
tempNode=tempNode->next;
}
if(addNumber==1)
{
ListNode* temp=new ListNode(1);
cl1->next=temp;
}
return l1;
}
};
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
//注意两个链表的长度可能不一样长
int addNumber=0;
ListNode* cl1=l1,* cl2=l2,* tempNode=l1;
while(cl1&&cl2)
{
int temp=cl1->val+cl2->val+addNumber;
if(temp>9){
addNumber=1;
cl1->val=temp-10;
}
else{
addNumber=0;
cl1->val=temp;
}
tempNode=cl1;
cl1=cl1->next;
cl2=cl2->next;
}
if(cl1==NULL&&cl2!=NULL)
{
tempNode->next=cl2;
}
while(tempNode)
{
int temp=tempNode->val+addNumber;//有错
if(temp>9){
addNumber=1;
tempNode->val=temp-10;
}
else{
addNumber=0;
tempNode->val=temp;
}
cl1=tempNode;
tempNode=tempNode->next;
}
if(addNumber==1)
{
ListNode* temp=new ListNode(1);
cl1->next=temp;
}
return l1;
}
};方法：新建一个链表，在循环中单独判断两个链表是否为空，使用sum保存每次的加和，并在链表中保存余数，在下一次循环中，这个sum值的起始值是除10后的数。
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode *c1=l1;
ListNode *c2=l2;
ListNode * result=new ListNode(0);
ListNode* tempNode=result;
int sum=0;
while(c1||c2)
{
sum/=10;
if(c1)
{
sum+=c1->val;
c1=c1->next;
}
if(c2){
sum+=c2->val;
c2=c2->next;
}
tempNode->next=new ListNode(sum%10);
tempNode=tempNode->next;
}
if(sum>9)
{
tempNode->next=new ListNode(1);
}
return result->next;
}
};
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode *c1=l1;
ListNode *c2=l2;
ListNode * result=new ListNode(0);
ListNode* tempNode=result;
int sum=0;
while(c1||c2)
{
sum/=10;
if(c1)
{
sum+=c1->val;
c1=c1->next;
}
if(c2){
sum+=c2->val;
c2=c2->next;
}
tempNode->next=new ListNode(sum%10);
tempNode=tempNode->next;
}
if(sum>9)
{
tempNode->next=new ListNode(1);
}
return result->next;
}
};另外一种方法：使用条件运算符简化代码
class Solution { public: ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { ListNode* p=new ListNode(0); ListNode * temp=p; int extra=0; while(l1||l2||extra){ int sum=extra+(l1?l1->val:0)+(l2?l2->val:0); extra=sum/10; temp->next=new ListNode(sum%10); temp=temp->next; l1=l1?l1->next:l1; l2=l2?l2->next:l2; } return p->next; } };
445Add Two Numbers II46.1%Medium
描述：这个题目是增进版本，高位数在前面，低位数在后面Example:
Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4) Output: 7 -> 8 -> 0 -> 7
24Swap Nodes in Pairs38.2%Medium
给定一个链表，交换两个相邻的节点只能使用常数空间，不能更改节点的值
Given
1->2->3->4
, you should return the list as
2->1->4->3
.
思路：
因为第一个节点会变，所以设置表头指针。
由于奇偶性不同，一次循环需要处理两个节点。
如果是奇数个，最后一个节点不动。
自己写的代码： 题目比较简单，主要是考虑每次循环如何处理（要做三次指针操作，并且保存下一次循环的指针p）
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
if(head==NULL) return head;
ListNode* preHead=new ListNode(0);
preHead->next=head;
ListNode* p=preHead;
while(p->next&&p->next->next){
ListNode* next=p->next;
ListNode* nextNext=next->next;
ListNode* third=nextNext->next;
p->next=nextNext;
nextNext->next=next;
next->next=third;
p=next;
}
return preHead->next;
}
};
86Partition List 32.5%Medium 类似快速排序
给定一个数，将链表重新排序
Given
return
1->4->3->2->5->2 and x = 3,return
1->2->2->4->3->5.
自己的思路：设置两个指针，分别指向小于指定数和大于指定数。当遍历完成之后，合并两个链表。
小链表要保存头部作为所有的头，大链表也要保存头部与小链表的尾部相连，大链表的为节点需要指向NULL。
如果所有的值都小于这个数，和所有值都大于这个数，程序也可以正常执行
class Solution {
public:
ListNode* partition(ListNode* head, int x) {
if(head==NULL) return head;
ListNode* small=new ListNode(-1);
ListNode* big=new ListNode(-1);
ListNode* smallCopy=small;
ListNode* bigCopy=big;
while(head){
if(head->val<x){
smallCopy->next=head;
smallCopy=head;
}
else
{
bigCopy->next=head;
bigCopy=head;
}
head=head->next;
}
bigCopy->next=NULL;
smallCopy->next=big->next;
delete big;
delete small;
return small->next;
}
};82Remove Duplicates from Sorted List II29.4%Medium
给定一个排序链表，去除链表中所有重复的数，注意重复的数字全部去除。与版本I不同，版本1是留下一个重复的数字。
自己的思路：设置起始头结点，它所指向的数必须和后面的数不同。编不下去喽
看别人的思路：
使用递归
放一放吧
328Odd Even Linked List 43.4%Medium
将一个链表原来处在奇数位置的节点放到前面，偶数位置的节点放到后面
Example:
Given
return
Given
1->2->3->4->5->NULL,return
1->3->5->2->4->NULL.
自己的思路：与86题思路类似，设置两个表头指针odd和even，分别指向奇数和偶数节点，完成后将奇数节点的尾节点指向偶数的头结点。
class Solution {
public:
ListNode* oddEvenList(ListNode* head) {
ListNode* preOdd=new ListNode(-1);
ListNode* preEven=new ListNode(-1);
ListNode* odd=preOdd;
ListNode* even=preEven;
bool oddOrEven=true;//奇数为true，偶数为false
while(head){
if(oddOrEven){
odd->next=head;
odd=head;
oddOrEven=false;
}
else{
even->next=head;
even=head;
oddOrEven=true;
}
head=head->next;
}
even->next=NULL;
odd->next=preEven->next;
return preOdd->next;
}
};109Convert Sorted List to Binary Search Tree 33.8%Medium
148 sort list
将一个链表排序，要求时间复杂度是
O
(
n
log
n
)，空间复杂度是1.
使用归并排序
147 insertion sort list
使用直接插入排序将一个链表排序。
25. Reverse Nodes in k-Group
自己写的代码：
class Solution {
public:
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode* last=head;
ListNode*newHead=new ListNode(0);
newHead->next=head;
ListNode* first=newHead;
int n=1;
while(last)
{
if(n==k) {//如果收集到了k个节点
ListNode* pre=last->next;
ListNode* temp=first->next;
ListNode* nowHead=first->next;
while(n)
{
ListNode* next=nowHead->next;
nowHead->next=pre;
pre=nowHead;
nowHead=next;
n--;
}
n=1;
first->next=pre;
first=temp;
last=first->next;
continue;
}
last=last->next;
n++;
}
n--;
return newHead->next;
}
};
736
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
