LintCode 99: Reorder List (链表经典题)

原创已于 2023-09-14 11:56:46 修改 · 177 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode

于 2019-06-09 06:36:53 首次发布

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文介绍了一种链表重排序算法，将链表L0→L1→...→Ln-1→Ln重新排列为L0→Ln→L1→Ln-1→L2→Ln-2→...。通过找到链表中点，反转右半边链表，并将其逐个插入左半边链表实现。此外，还提供了一种使用stack的方法。

Reorder List
中文English
Given a singly linked list L: L0 → L1 → … → Ln-1 → Ln

reorder it to: L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

Example
Example 1:
Input: 1->2->3->4->null
Output: 1->4->2->3->null

Example 2:
Input: 1->2->3->4->5->null
Output: 1->5->2->4->3->null

Challenge
Can you do this in-place without altering the nodes’ values?

解法1：先找到链表中点，然后把右半边链表反转，然后挨个插入左半边链表中。
代码如下：

/**
 * Definition of singly-linked-list:
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 *     ListNode(int val) {
 *        this->val = val;
 *        this->next = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param head: The head of linked list.
     * @return: nothing
     */
    void reorderList(ListNode * head) {
        if (!head || !head->next) return; 
    
        ListNode * mid = findMiddle(head);
        ListNode * rightHead = reverseList(mid->next);
        mid->next = NULL;
        
        ListNode * p = head, * pRight = rightHead;
        while(p && pRight) {
            ListNode * pNext = p->next;
            ListNode * pRightNext = pRight->next;
            
            p->next = pRight;
            pRight->next = pNext;
            
            p = pNext;
            pRight = pRightNext;
        }
        
        return;
    }
    
private:
    ListNode * findMiddle(ListNode * head) {
        ListNode * slow = head, * fast = head->next;
        while(fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
    
    ListNode * reverseList(ListNode * head) {
        ListNode * pre = NULL;
        while(head) {
            ListNode * tmpNode = head->next;
            head->next = pre;
            pre = head;
            head = tmpNode;
        }
        
        return pre;
    } 
};

解法2：用stack。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    void reorderList(ListNode* head) {
        stack<ListNode *> stk;
        ListNode *node = head;
        while (node) {
            stk.push(node);
            node = node->next;
        }
        node = head;
        while (!stk.empty()) {
            ListNode *topNode = stk.top();
            stk.pop();
            if (node == topNode) {
                node->next = NULL;
                break;
            }
            if (node && node->next == topNode) {
                topNode->next = NULL;
                break;
            }            
            topNode->next = node->next;
            node->next = topNode;
            node = topNode->next;
        }
        return;
    }
};