leetcode143. Reorder List

medium程度题

题目:

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}.

我想的是把n个节点存入容器，然后遍历容器改造节点，时间复杂度O(N)，空间复杂度O（N）

AC解:

class Solution {
public:
    void reorderList(ListNode* head)
    {
        if (head == nullptr || head->next == nullptr)
            return ;
        vector<ListNode*> vec;
        //遍历一遍链表,所有节点存入vec
        ListNode *cur = head;
        while (cur)
        {
            vec.push_back(cur);
            cur = cur->next;
        }
        //改造节点
        auto first = vec.begin();
        auto second = vec.end() - 1;
        while (first < second)
        {
            (*first)->next = *second;
            first++;
            (*second)->next = *first;
            second--;
        }
        
        (*first)->next = nullptr;
    }
};

另有一种空间复杂度O(1)的解法，把链表拆分成两个，将后面的链表翻转，然后合并两个链表

AC解:

class Solution {
public:
    void reorderList(ListNode* head)
    {
        if (head == nullptr || head->next == nullptr)
            return ;
        ListNode *fast = head,*slow = head,*prev = nullptr;
        //拆分链表
        while (fast && fast->next)
        {
            prev = slow;
            slow = slow->next;
            fast = fast->next->next;
        }
        
        prev->next = nullptr;
        slow = reverse(slow);
        //合并两个链表
        ListNode *cur = head;
        while (cur->next)
        {
            ListNode *temp = cur->next;
            cur->next = slow;
            slow = slow->next;
            cur->next->next = temp;
            cur = temp;
        }
        
        cur->next = slow;
    }
    
    ListNode* reverse(ListNode *head)
    {
        if (head == nullptr || head->next == nullptr)
            return head;
        ListNode *prev = head;
        for (ListNode *cur = head->next,*next = cur->next; cur;)
        {
            head->next = next;
            cur->next = prev;
            prev = cur;
            cur = next;
            
            next = next ? next->next : nullptr;
        }
        
        return prev;
    }
};

两种解法时间性能上没有差别