143. 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步，直到快指针触到了链表的末端。最终慢指针对应的就是链表的后半部分。在该题的情况下，只需要对满指针的下一个以及随后的节点进行逆置即可。

　　得到逆置后的后半部分以及前半部分之后，先将链表从快慢指针之间截断，然后进行循环遍历。在本题中，后半部分的节点个数，小于或等于前半部分，循环结束的标志也就是后半部分是否已经到达末尾。在插入的操作中，只需要注意变量值的交换(两个节点的next值)即可，代码如下：

/**
 * 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)
    {
        //对链表进行逆置
        if(head==NULL) return NULL;
        ListNode* tail = head;
        while(tail->next!=NULL)
            tail = tail->next;
        
        ListNode* curr = head;
        while(curr!=tail)
        {
            ListNode* temp = curr->next;
            curr->next = tail->next;
            tail->next = curr;
            curr = temp;
        }
        return tail;
    }
    
    void reorderList(ListNode* head) 
    {
        if(head==NULL) return;
        
        //通过快慢指针来找到链表的中点
        ListNode *fast = head;
        ListNode *slow = head;
        while(fast->next!=NULL&&fast->next->next!=NULL)
        {
            fast = fast->next->next;
            slow = slow->next;
        }
        //链表中如果只有一个或两个节点，无需进行下面的操作了，直接返回
        if(fast==slow) return;
        
        ListNode* slow_rev = reverseList(slow->next);
        //将链表从中间断开
        slow->next = NULL;
        ListNode* curr = head;
        //合并两个链表
        while(slow_rev)//后半段的链表节点数比前半段的少
        {
            ListNode* temp1 = slow_rev->next;
            ListNode* temp2 = curr->next;
            curr->next = slow_rev;
            slow_rev->next = temp2;
            slow_rev = temp1;
            curr = temp2;
        }
        
    }
};