链表排序

最新推荐文章于 2025-07-09 21:33:09 发布

原创最新推荐文章于 2025-07-09 21:33:09 发布 · 3.3k 阅读

6 ·

CC 4.0 BY-SA版权

算法专栏收录该内容

5 篇文章

订阅专栏

本文探讨了如何在O(nlogn)的时间复杂度和常数级空间复杂度下对单链表进行排序，详细介绍了基于LeetCode 148题的快速排序和归并排序两种实现方式，并提供了相关代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 单链表排序时间复杂度O(nlogn)----快速排序实现、归并排序实现

leetcode 148

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 1:

输入: 4->2->1->3
输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

代码实现

#include <iostream>
#include <queue>
using namespace std;

struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
private:
	// 快速排序实现
	void qswap(int *a, int *b) {
		int temp = *a;
		*a = *b;
		*b = temp;
	}
	ListNode* qsort(ListNode* nbegin, ListNode* nend) {
		if (nbegin == nend || nbegin->next == nend)
			return nbegin;
		int value = nbegin->val;
		ListNode* p = nbegin; 
		ListNode* q = nbegin;
		while (q != nend) {
			if (q->val < value) {
				p = p->next;
				qswap(&p->val, &q->val);
			}
			q = q->next;
		}
		qswap(&p->val, &nbegin->val);
		return p;
	}
	void quicksort(ListNode* nbegin, ListNode* nend) {
		if (nbegin == nend || nbegin->next == nend)
			return;
		ListNode* mid = qsort(nbegin, nend);
		quicksort(nbegin, mid);
		quicksort(mid->next, nend);
	}

	//归并排序实现
	ListNode* mergesort(ListNode* head) {
		if (head == NULL || head->next == NULL)
			return head;
		ListNode* midNode = getMid(head);
		ListNode* head1 = mergesort(head);
		ListNode* head2 = mergesort(midNode);
		return merge(head1, head2);
	}

	ListNode* merge(ListNode* head1, ListNode* head2) {
		ListNode* dummyNode = new ListNode(-1);
		ListNode* pre = dummyNode;
		while (head1 != NULL && head2 != NULL) {
			if (head1->val <= head2->val) {
				pre->next = head1;
				head1 = head1->next;
			}
			else {
				pre->next = head2;
				head2 = head2->next;
			}
			pre = pre->next;
		}
		if (head1 != NULL)
			pre->next = head1;
		else if (head2 != NULL)
			pre->next = head2;

		ListNode* resNode = dummyNode->next;
		delete dummyNode;
		return resNode;
	}

	ListNode* getMid(ListNode* head) {
		if (head == NULL || head->next == NULL)
			return NULL;
		ListNode* cur1 = head;
		ListNode* cur2 = head;
		ListNode* pre = head;

		while (cur2->next != NULL && cur2->next->next != NULL) {
			pre = cur1;
			cur1 = cur1->next;
			cur2 = cur2->next->next;
		}
		if (cur2->next != NULL) {
			pre = cur1;
			cur1 = cur1->next;
		}
		pre->next = NULL;
		return cur1;
	}

public:
	ListNode* sortList(ListNode* head) {
		if (head == NULL || head->next == NULL) {
			return head;
		}
		// 使用快速排序实现
		quicksort(head, NULL);
		return head;

		// 使用归并排序实现
		//return mergesort(head);
	}
};

参考博客：单链表排序----快排 & 归并排序