难度中等511
给定一个单链表 L:L0→L1→…→Ln-1→Ln ,
将其重新排列后变为: L0→Ln→L1→Ln-1→L2→Ln-2→…你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
示例 1:
给定链表 1->2->3->4, 重新排列为 1->4->2->3.
示例 2:
给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.
1、链表数组存储链表,然后利用数组的索引进行重新排列
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
void reorderList(ListNode* head) {
if(head == nullptr){
return ;
}
vector<ListNode*> vec;
ListNode* node = head;
while(node != nullptr){
vec.push_back(node);
node = node->next;
}
int i = 0, j = vec.size()-1;
while(i < j){
vec[i]->next = vec[j];
i++;
if(i == j){
break;
}
vec[j]->next = vec[i];
j--;
}
vec[i]->next = nullptr;
}
};
2、找中点-反转-合并
大概的思路是这样的:
先找到链表的中点,然后对中点之后的节点全部反转,最后合并的过程比较复杂需要仔细的在纸上画画过程找找规律。总之,在官方题解中学习到很多。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
void reorderList(ListNode* head) {
if(head == nullptr){
return ;
}
ListNode* mid = middleNode(head);
ListNode* l1 = head;
ListNode* l2 = mid->next;
mid->next = nullptr;
l2 = reverseList(l2);
mergeList(l1, l2);
}
ListNode* middleNode(ListNode* head){
ListNode* slow = head;
ListNode* fast = head;
while(fast->next != nullptr && fast->next->next != nullptr) {
slow = slow->next;
fast = fast->next->next;
}
return slow;
}
ListNode* reverseList(ListNode* head){
ListNode* prev = nullptr;
ListNode* curr = head;
while(curr != nullptr){
ListNode* tmp = curr->next;
curr->next = prev;
prev = curr;
curr = tmp;
}
return prev;
}
void mergeList(ListNode* l1, ListNode* l2){
ListNode* l1_tmp, *l2_tmp;
while(l1 != nullptr && l2 != nullptr){
l1_tmp = l1->next;
l2_tmp = l2->next;
l1->next = l2;
l1 = l1_tmp;
l2->next = l1;
l2 = l2_tmp;
}
}
};
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
void reorderList(ListNode* head) {
if(head == nullptr || head->next == nullptr || head->next->next == nullptr){
return;
}
ListNode *slow = head, *fast = head->next;
while(fast != nullptr && fast->next != nullptr){
slow = slow->next;
fast = fast->next->next;
} //找中点
//2 断开中点后,反转后半部分
ListNode *head2 = nullptr, *nxt = slow->next;
slow->next = nullptr;
slow = nxt;
while(slow != nullptr){
nxt = slow->next;
slow->next = head2;
head2 = slow;
slow = nxt;
}
//3 合并链表
ListNode* curr = head, *curr2 = head2;
while(curr != nullptr && curr2 != nullptr){
nxt = curr->next;
curr->next = curr2;
curr2 = curr2->next;
curr->next->next = nxt;
curr = nxt;
}
}
};