[LeetCode 143] Reorder List Solution

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}

.
Ideas: 1. First of all, check the list is null or has only one or two element(s).

2. find the middle node of list, get the second half part of the last list

3. reverse the second half part of last list.

4. insert the second half part of list into the first half part of list

Passed:

/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
void reorderList(ListNode *head) {
if(head == NULL || head->next == NULL || head->next->next ==NULL)
return;

ListNode
*p = head,
*q = head;
//get the middle node
while(p->next!= NULL && p->next->next!= NULL)
{
q = q->next;
p = p->next->next;
}

//q is the last element of the first half part list
//reverse the second half part list
p = reverseList(q->next);
q->next = NULL;

//Reorder the list
q = head;
ListNode *first = NULL;
ListNode *second = NULL;
while(p)
{
first = q->next;
q->next = p;

second = p->next;
p->next = first;

p = second;
q = first;
}
return;
}

private:
ListNode * reverseList(ListNode *half)
{
if(half == NULL || half->next == NULL)
return half;

ListNode *temp = NULL;
ListNode *tempHead = NULL;

while(half)
{
temp = half;
half = half->next;
temp->next = tempHead;
tempHead = temp;
}

return tempHead;
}

};

 

NOTPassed

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
void reorderList(ListNode *head) {
//check the initial condition
if(head == nullptr || head->next == nullptr || head->next->next == nullptr) {
return;
}

//Get the second half position of the list
//using slow and fast pointer
ListNode
*slow = head,
*fast = head;
while(fast != nullptr)
{
fast = fast->next;
if(fast->next != nullptr)
{
fast = fast->next;
}
else
{
break;
}
slow = slow->next;
}

ListNode
*halfHead = slow->next;
slow->next = nullptr;

//reserve the second half of list
slow = halfHead;
ListNode *cur = halfHead;
halfHead = nullptr;

while(slow != nullptr)
{
cur = slow;
slow = slow->next;
cur->next = halfHead;
halfHead = cur;
}

//merge two list head and half head
fast = head;
ListNode *curFast = head;
slow = halfHead;
ListNode *curSlow = halfHead;

while(fast != nullptr && slow != nullptr)
{
curFast = fast->next;
fast->next = slow;

curSlow = slow->next;
slow->next =  curFast;

fast = curFast;
slow = curSlow;
}

return;
}
};

Notes:
In- place algorithm is an algorithm which transforms input using a data structure with a small, constant amount of extra storage space.