24. 两两交换链表中的节点
原题
给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。
你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.
法1:迭代法
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummy=new ListNode(-1);
dummy->next=head;
ListNode* pre=dummy;
ListNode* back=head;
for(int i=0;i<2;i++){
if(back){
back=back->next;
}else{
return head;
}
}
ListNode* a=head;ListNode* b=head->next;
while(back!=NULL){
pre->next=b;b->next=a;a->next=back;
pre=a;a=back;
if(back->next){
b=back->next;
}else{
break;
}
back=b->next;
}
if(back==NULL){
pre->next=b;b->next=a;a->next=back;
}
return dummy->next;
}
};
法2:递归法
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
if(head==NULL||head->next==NULL){
return head;
}
ListNode* firstNode=head;
ListNode* secondNode=head->next;
firstNode->next=swapPairs(secondNode->next);
secondNode->next=firstNode;
return secondNode;
}
};
206. 反转链表
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
/**
* 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) {
ListNode* pre=NULL;
ListNode* tail=head;
while(tail!=NULL){
ListNode* tmp=tail->next;
tail->next=pre;
pre=tail;
tail=tmp;
}
return pre;
}
};
25. K 个一组翻转链表
题目
给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。
k 是一个正整数,它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。
给你这个链表:1->2->3->4->5
当 k = 2 时,应当返回: 2->1->4->3->5
当 k = 3 时,应当返回: 3->2->1->4->5
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
pair<ListNode*, ListNode*> reverse(ListNode* head,ListNode* tail){
ListNode* pre=NULL;
ListNode* cur=head;
while(pre!=tail){
ListNode* tmp=cur->next;
cur->next=pre;
pre=cur;cur=tmp;
}
return {pre,head};
}
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode* dummy=new ListNode(0);
dummy->next=head;
ListNode* pre=dummy;
while(head){
ListNode* tail=pre;
for(int i=0;i<k;i++){
tail=tail->next;
if(!tail){
return dummy->next;
}
}
ListNode* back=tail->next;
pair<ListNode*,ListNode*> result=reverse(head,tail);
head=result.first;tail=result.second;
pre->next = head;
tail->next = back;
pre = tail;
head = tail->next;
}
return dummy->next;
}
};