[leetcode] 143. Reorder List

Description

Given a singly linked list L: L0→L1→…→Ln-1→Ln,
reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…

You may not modify the values in the list’s nodes, only nodes itself may be changed.

Example 1:

Given 1->2->3->4, reorder it to 1->4->2->3.

Example 2:

Given 1->2->3->4->5, reorder it to 1->5->2->4->3.

分析

题目的意思是：重新排列链表，按照L0→Ln→L1→Ln-1→L2→Ln-2→…这种顺序。

• 先用快慢指针找到中间结点，然后后面用栈进行反转，然后插入到前面的链表中。

C++

/**
 * 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||!head->next||!head->next->next){
            return ;
        }
        ListNode* slow=head;
        ListNode* fast=head;
        while(fast->next&&fast->next->next){
            slow=slow->next;
            fast=fast->next->next;
        }
        ListNode* mid=slow->next;
        slow->next=NULL;
        ListNode* last=mid;
        ListNode* pre=NULL;
        while(last){
            ListNode* t=last->next;
            last->next=pre;
            pre=last;
            last=t;
        }
        while(pre&&head){
            ListNode* t=head->next;
            head->next=pre;
            pre=pre->next;
            head->next->next=t;
            head=t;
        }
    }
};

Python

首先找到中点，然后截断，对后面的链表进行反转，最后进行拼接。

class Solution:

    def reverse(self, root):
        prev = None
        cur = root
        while cur:
            next_t = cur.next
            cur.next = prev
            prev = cur
            cur = next_t
        return prev

    def middle_node(self, head):
        first, second = head, head
        while second.next and second.next.next:
            first = first.next
            second = second.next.next
        return first


    def reorderList(self, head: Optional[ListNode]) -> None:
        if not head or not head.next:
            return head
        root = ListNode(0)
        root.next = head
        
        mid = self.middle_node(head)
        # reverse
        middle = mid.next
        mid.next = None
        reverse_middle = self.reverse(middle)
        
        # concat
        l = head
        r = reverse_middle
        while r and l:
            l_next = l.next
            r_next = r.next

            l.next = r
            l = l_next

            r.next = l
            r = r_next

参考文献

[编程题]reorder-list