LeetCode - Reorder List

Reorder List

2014.1.13 22:07

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}

.

Solution1:

　　My solution for this problem is in three steps:

　　　　1. cut the list in two halves of equal length (maybe differ by 1).

　　　　2. reverse the latter one.

　　　　3. merge them in a crossing manner: 1->2->1->2->1->...

　　Time complexity is O(n), space complexity is O(1), where n is the number of nodes in the list.

Accepted code:

// 4CE, 1AC, if you're able to design the right algorithm with just one shot, why failed by 4 foolish CEs?
/**
* 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) {
// IMPORTANT: Please reset any member data you declared, as
// the same Solution instance will be reused for each test case.
if(head == nullptr){
// 1CE here, void function...
return;
}

int n, n1, n2;
// 1CE here, ListNode, not List...
ListNode *h1, *h2, *ptr;

h1 = head;
ptr = head;
n = 0;
while(ptr != nullptr){
++n;
ptr = ptr->next;
}
n1 = (n + 1) / 2;
n2 = n - n1;
ptr = head;
// 1CE here, declaration for $i missing
for(int i = 1; i < n1; ++i){
ptr = ptr->next;
}
h2 = ptr->next;
ptr->next = nullptr;
h2 = reverseList(h2);

ListNode *root = new ListNode(0), *tail;
ListNode *p1, *p2;
tail = root;
while(h1 != nullptr || h2 != nullptr){
if(h1 != nullptr){
tail->next = h1;
h1 = h1->next;
tail = tail->next;
tail->next = nullptr;
}
if(h2 != nullptr){
tail->next = h2;
h2 = h2->next;
tail = tail->next;
tail->next = nullptr;
}
}

head = root->next;
delete root;
// 1CE here, void function has no return
}
private:
ListNode *reverseList(ListNode *head) {
if(nullptr == head){
return head;
}

ListNode *ptr1, *ptr2, *root;

root = new ListNode(0);
ptr1 = head;
while(ptr1 != nullptr){
ptr2 = root->next;
root->next = ptr1;
ptr1 = ptr1->next;
root->next->next = ptr2;
}

head = root->next;
delete root;
return head;
}
};

Solution2:

　　I've noticed that I used an extra new operation in the code. This overhead can be avoided.

Accepted code:

// 2WA, 1AC, not so satisfactory
class Solution {
public:
void reorderList(ListNode *head) {
if(head == nullptr){
return;
}

int n, n1, n2;
ListNode *h1, *h2, *ptr;

h1 = head;
ptr = head;
n = 0;
while(ptr != nullptr){
++n;
ptr = ptr->next;
}
n1 = (n + 1) / 2;
n2 = n - n1;
ptr = head;
for(int i = 1; i < n1; ++i){
ptr = ptr->next;
}
h2 = ptr->next;
ptr->next = nullptr;
h2 = reverseList(h2);

ListNode *tail;
ListNode *p1, *p2;
tail = nullptr;
head = h1;
while(h1 != nullptr || h2 != nullptr){
if(h1 != nullptr){
if(tail != nullptr){
tail->next = h1;
tail = tail->next;
}else{
tail = h1;
}
h1 = h1->next;
tail->next = nullptr;
}
if(h2 != nullptr){
if(tail != nullptr){
tail->next = h2;
tail = tail->next;
}else{
tail = h2;
}
h2 = h2->next;
tail->next = nullptr;
}
}
}
private:
ListNode *reverseList(ListNode *head) {
if(nullptr == head){
return head;
}

ListNode *ptr1, *ptr2;

ptr1 = head;
head = nullptr;
while(ptr1 != nullptr){
ptr2 = ptr1;
ptr1 = ptr1->next;
if(head != nullptr){
// 2WA here, better manually debug it before submission
ptr2->next = head;
head = ptr2;
}else{
head = ptr2;
ptr2->next = nullptr;
}
}

return head;
}
};