Reorder List [leetcode] 的两种思路

最新推荐文章于 2020-08-09 07:56:41 发布

原创最新推荐文章于 2020-08-09 07:56:41 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 专栏收录该内容

59 篇文章

订阅专栏

本文详细介绍了两种链表重组算法的实现过程，包括使用向量存储节点和通过中间节点翻转链表的方法。文章提供了完整的代码示例，帮助读者理解如何在不同场景下灵活运用这些技巧。

第一种思路是用一个vector存所有的Node*

之后再用两个指针将链表拼接出来

    void reorderList(ListNode *head) {
        vector<ListNode*> content;
        ListNode * cur = head;
        while (cur)
        {
            content.push_back(cur);
            cur = cur->next;
        }
        int size = content.size();
        cur = NULL;
        for (int i = 0; i <= size - 1 - i; i++)
        {
            if (cur) cur->next = content[i];
            if (i != size - i - 1) content[i]->next = content[size - 1 - i];
            cur = content[size - 1 - i];
        }
        if (cur) cur->next = NULL;
    }

第二种思路可以分成以下几个步骤：

1. 找到中间的节点nMid

2. 翻转nMid到末尾的链表

3. 拼接head和nMid

代码如下

    void reorderList(ListNode *head) {
        if (head == NULL) return;
        ListNode * mid = head;
        ListNode * endOfHead;
        ListNode * end = head;
        while (end)
        {
            end = end->next;
            endOfHead = mid;
            mid = mid->next;
            if (end)  end = end->next;
        }
        endOfHead->next = NULL;//end of first half
        //reverse
        if (mid == NULL) return;
        ListNode* p0, * p1, * p2;
        p1 = mid;
        p2 = mid->next;
		p1->next = NULL;
        while (p2)
        {
            p0 = p1;
            p1 = p2;
            p2 = p2->next;
            p1->next = p0;
        }
        mid = p1;
        //concat
        ListNode * newHead = head;
        while (mid && head)
        {
            head = head->next;
            newHead->next = mid;
            newHead = newHead->next;
            mid = mid->next;
            newHead->next = head;
            newHead = newHead->next;
        }
    }