LeetCode OJ Sort List

最新推荐文章于 2020-01-21 18:25:06 发布

kassical

最新推荐文章于 2020-01-21 18:25:06 发布

阅读量706

点赞数

分类专栏： LeetCode 文章标签：算法 leetcode 归并排序快速排序

本文链接：https://blog.csdn.net/kassical/article/details/37620831

版权

LeetCode 专栏收录该内容

98 篇文章 0 订阅

订阅专栏

Sort List

Sort a linked list in O(n log n) time using constant space complexity.

先使用了快速排序，结果超时，后改为归并排序才Accepted。

快速排序：

class Solution {
public:
	ListNode *sortList(ListNode *head) {

		QuickSortList(head, NULL);
		return head;
	}

	void QuickSortList(ListNode *head, ListNode *last)
	{
		if (head == NULL || head == last)
			return;
		
		ListNode *slow = head;
		ListNode *fast = head->next;

		while (fast != last) {           //最后一个节点last不比较，或者为上一次的分割节点 或者为 NULL
			if (fast->val < head->val) {
				slow = slow->next;
				exch(&slow->val, &fast->val);
			}
			fast = fast->next;
		}
		exch(&head->val, &slow->val);

		QuickSortList(head, slow);
		QuickSortList(slow->next, last);  //slow->next 至多和 last 相等， 不会到last之后
	}

	void exch(int *a, int *b)
	{
		int t = *a;
		*a = *b;
		*b = t;
	}
};

归并排序：

class Solution {
public:
  ListNode *sortList(ListNode *head) {
		if (head == NULL || head->next == NULL)
			return head;

		ListNode *pOneStep = head;
		ListNode *pTwoStep = head;
		while (pTwoStep->next != NULL && pTwoStep->next->next != NULL) {
			pOneStep = pOneStep->next;
			pTwoStep = pTwoStep->next->next;
		}
		pTwoStep = pOneStep->next;
		pOneStep->next = NULL;

		pOneStep = sortList(head);
		pTwoStep = sortList(pTwoStep);
		return merge(pOneStep, pTwoStep);
	}

	ListNode *merge(ListNode *pOne, ListNode *pTwo)
	{
		ListNode head(0);
		ListNode *p = &head;
		while (pOne != NULL && pTwo != NULL) {
			if (pOne->val <= pTwo->val) {
				p->next = pOne;
				p = pOne;
				pOne = pOne->next;
			}
			else {
				p->next = pTwo;
				p = pTwo;
				pTwo = pTwo->next;
			}
		}
		p->next = (pOne == NULL) ? pTwo : pOne;
		return head.next;
	}
};