]Leetcode]-[Reorder 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}

.

题目的意思就是，给定一个链表，从两头开始链接，

比如1-2-3-4-5-6，最开始取两头，组成1-6，剩下2-3-4-5；

接着取两头，2-5，和上面的1-6连接起来，组成1-6-2-5，剩下3-4；

接着取两头， 3-4，同理和上面的结果连接起来，组成 1-6-2-5-3-4；

我一共做了3种解法：第一种解法，使用递归的解法，每次都取两头，然后递归的去解；一共递归n/2次，每次需要从头开始遍历到最后一个元素，需要n步，所以时间复杂度是O(N*N),， 空间复杂度O(1). 但是结果是超时了。。。

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:

ListNode *recurse(ListNode *head)
{
if(head == NULL || head->next == NULL)
{
return head;
}
ListNode *cur = head, *pre = head;
while(cur->next != NULL)
{
pre = cur;
cur = cur->next;
}
pre->next = NULL;
ListNode *next = head->next;
head->next = cur;
cur->next = recurse(next);
return head;
}
void reorderList(ListNode *head)
{
if(head == NULL || head->next == NULL)
return;
head =recurse(head);

}
};

第二种解法，比较有效率，O(N)的时间复杂度，O(1)空间复杂度。思路是：将链表平均分为前后2段（l和r），将r倒转，然后按照顺序将l和r拼接起来。AC了

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:

ListNode *split(ListNode *head)
{
ListNode *p = head;
ListNode *q = head->next;
while(q != NULL && q->next != NULL)
{
q = q->next->next;
p = p->next;
}
q = p->next;
p->next = NULL;
return q;
}

ListNode *reverse(ListNode *head)
{
if(head == NULL || head->next == NULL)
return head;
ListNode *pre = head, *cur = head->next, *next;
head->next = NULL;
while(cur != NULL)
{
next = cur->next;
cur->next = pre;
pre = cur;
cur = next;
}
return pre;
}
void reorderList(ListNode *head)
{
if(head == NULL || head->next == NULL)
return;
ListNode *r = reverse(split(head));
ListNode *l = head->next;
ListNode *traverse = head;
while(r != NULL && l != NULL)
{
ListNode *tmp_r = r->next;
ListNode *tmp_l = l->next;
traverse->next = r;
traverse = traverse->next;
traverse->next = l;
traverse = traverse->next;
l = tmp_l;
r = tmp_r;
}
if(r != NULL)
traverse->next = r;
else
traverse->next = l;
}
};

最后一种解法是最直接的，借助了一个O(N)的空间，写起来比较简单，而且代码很容易懂，依然O(N)的时间复杂度，比第二种解法快了3ms。

/**
* 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)
return;
vector<ListNode *> vec;
ListNode *p = head->next;
while(p != NULL)
{
vec.push_back(p);
p = p->next;
}
p = head;
vector<ListNode *>::size_type i, j;
for(i = 0, j = vec.size() - 1; i < j; i++, j--)
{
p->next = vec[j];
p = p->next;
p->next = vec[i];
p = p->next;
}
if(i == j)
{
p->next = vec[i];
p = p->next;
}
p->next = NULL;
}
};