链表OJ（四）链表排序合集

目录

合并两个排序的链表

合并k个已排序的链表

单链表的排序

链表的奇偶重排

链表的奇偶重排扩展

---

合并两个排序的链表

描述

输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

数据范围： 0≤n≤10000≤n≤1000，−1000≤节点值≤1000−1000≤节点值≤1000
要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}，转换过程如下图所示：

或输入{-1,2,4},{1,3,4}时，合并后的链表为{-1,1,2,3,4,4}，所以对应的输出为{-1,1,2,3,4,4}，转换过程如下图所示：

示例1

class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
		ListNode* newhead = new ListNode(0);
		ListNode* p = newhead;
		ListNode* l1 = pHead1, *l2 = pHead2;
		while(l1 && l2)
		{
			if(l1->val <= l2->val)    // 创建一个头结点，让头结点依次按序接入各个结点
			{
				p->next = l1;
				l1 = l1->next;
			}
			else
			{
				p->next = l2;
				l2 = l2->next;
			}
		 	p = p->next;
		}
		p->next = l1 ? l1 : l2;    // 记得循环跳出后对剩余结点的接入
		return newhead->next;
    }
};

合并k个已排序的链表

描述

合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。

数据范围：节点总数 0≤n≤50000≤n≤5000，每个节点的val满足 ∣val∣<=1000∣val∣<=1000

要求：时间复杂度 O(nlogn)O(nlogn)

使用优先级队列，存储依次存储各个链表，然后根据链表首部元素的大小进行建堆，

每次从堆中取出堆顶链表，将堆顶链表pop取出，得到头结点数据后，链表后移重新入队

class Com
{
public:
    bool operator()(ListNode* left, ListNode* right)
    {
        return left->val > right->val;
    }
};

class Solution {
public:
    ListNode *mergeKLists(vector<ListNode*> &lists) {
        if(lists.empty())return nullptr;
        priority_queue<ListNode*, vector<ListNode*>, Com> q;    // 创建一个优先级队列，按照大于的比较方式存储
        for(auto &e : lists)
        {
            if(e!=nullptr)      // 对每个不空的结点进行入队列
                q.push(e);
        }
        ListNode* newhead = new ListNode(0);
        newhead->next = nullptr;
        ListNode* pre = newhead;
        while(!q.empty())
        {
            ListNode* cur = q.top();    // cur标记当前堆顶结点
            q.pop();
            pre->next = cur;      // 将它插入返回链表中
            cur = cur->next;    // 当前结点后移一步
            if(cur) 
                q.push(cur);    // 如果不为空就重新入队列
            pre = pre->next;
        }
        return newhead->next;
    }
};

单链表的排序

描述

给定一个节点数为n的无序单链表，对其按升序排序。

数据范围：0<n≤1000000<n≤100000，保证节点权值在[−109,109][−109,109]之内。

要求：空间复杂度 O(n)O(n)，时间复杂度 O(nlogn)O(nlogn)

使用优先级队列，存储结点

class Com
{
public:
    bool operator()(const ListNode* left, const ListNode* right)
    {
        return left->val > right->val;
    }
};
class Solution {
public:
    ListNode* sortInList(ListNode* head) {
        // write code here
        priority_queue<ListNode*, vector<ListNode*>, Com> q;
        while(head)
        {
            q.push(head);        // 将每一个结点入队列
            head = head->next;
        }
        ListNode* newhead = new ListNode(0);
        ListNode* p = newhead;
        while(!q.empty())
        {
            ListNode* cur = q.top();    // 将堆顶结点依次取出置入新头结点后面
            q.pop();
            p->next = cur;
            p = p->next;
        }
        p->next = nullptr;
        return newhead->next;
    }
};

下面是使用按值存储并还原，这是因为上面的办法使用时我没有最后将p的next指向nullptr，导致p的屁股后面跟了一长串，这一长串都是一堆数据。

而上面的k个链表合并，他们每一个链表最终都走到了末尾空的位置。

class Com
{
public:
    bool operator()(const long long left, const long long right)
    {
        return left > right;
    }
};
class Solution {
public:
    ListNode* sortInList(ListNode* head) {
        // write code here            // 使用long long类型
        priority_queue<long long, vector<long long>, Com> q;
        while(head)
        {
            q.push(head->val);    // 存储值的优先级队列
            head = head->next;
        }
        ListNode* newhead = new ListNode(0);
        ListNode* p = newhead;
        while(!q.empty())
        {
            ListNode* cur = new ListNode(q.top());    // 用值将链表结点还原
            q.pop();
            p->next = cur;        // 插入newhead后面即可
            p = p->next;
        }
        return newhead->next;
    }
};

链表的奇偶重排

描述

给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。

注意是节点的编号而非节点的数值。

class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        // write code here
        if(head==nullptr)return nullptr;
        ListNode* slow = head, *fast = head->next;
        ListNode* link = fast;
        while(fast && fast->next)    // 注意这里fast 与 fast->next的判空
        {
            slow->next = fast->next;
            slow = slow->next;
            fast->next = slow->next;
            fast = fast->next;
            
            /*    俩种写法都可以
            slow->next = slow->next->next;
            fast->next = fast->next->next;
            slow = slow->next;
            fast = fast->next;
            */
        }
        slow->next = link;
        return head;
    }
};

链表的奇偶重排扩展

class Com
{
public:
    bool operator()(const ListNode* left, const ListNode* right)
    {
        return left->val > right->val;
    }
};
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        // write code here
        priority_queue<ListNode*, vector<ListNode*>, Com> q1;
        priority_queue<ListNode*, vector<ListNode*>, Com> q2;
        for(int i = 0; head; i++)
        {
            ListNode* newNode = new ListNode(head->val);
            if(i%2==0)
                q1.push(newNode);
            else
                q2.push(newNode);
            head = head->next;
        }
        ListNode* newhead1 = new ListNode(0);
        ListNode* p1 = newhead1;
        ListNode* newhead2 = new ListNode(0);
        ListNode* p2 = newhead2;
        while(!q1.empty())
        {
            p1->next = q1.top();
            q1.pop();
            p1 = p1->next;
        }
        while(!q2.empty())
        {
            p2->next = q2.top();
            q2.pop();
            p2 = p2->next;
        }
        p1->next = newhead2->next;
        p2->next = nullptr;
        return newhead1->next;
    }
};