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

思路：
利用额外空间，先用数组储存链表的值，排序，再用链表获取排好序的数组的值（不推荐）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
	ListNode* sortList(ListNode* head)
	{
		if (head == NULL||head->next==NULL)return head;
		int temp[100000];
		int i = 0;
		ListNode *p = head;
		while (p)
		{
			temp[i] = p->val;
			p = p->next;
			i++;
		}
		sort(temp, temp + i);
		p = head;
		i = 0;
		while (p)
		{
			p->val = temp[i];
			p = p->next;
			i++;
		}
		p = head;
		return p;
	}
};

思路2（归并排序）
归并排序法：在动手之前一直觉得空间复杂度为常量不太可能，因为原来使用归并时，都是 O(N)的，需要复制出相等的空间来进行赋值归并。对于链表，实际上是可以实现常数空间占用的（链表的归并排序不需要额外的空间）。利用归并的思想，递归地将当前链表分为两段，然后merge，分两段的方法是使用 fast-slow 法，用两个指针，一个每次走两步，一个走一步，直到快的走到了末尾，然后慢的所在位置就是中间位置，这样就分成了两段。merge时，把两段头部节点值比较，用一个 p 指向较小的，且记录第一个节点，然后两段的头一步一步向后走，p也一直向后走，总是指向较小节点，直至其中一个头为NULL，处理剩下的元素。最后返回记录的头即可。
主要考察3个知识点，
知识点1：归并排序的整体思想
知识点2：找到一个链表的中间节点的方法
知识点3：合并两个已排好序的链表为一个新的有序链表

归并排序的基本思想是：找到链表的middle节点，然后递归对前半部分和后半部分分别进行归并排序，最后对两个以排好序的链表进行Merge。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
private:
	ListNode* merge(ListNode* l, ListNode* r)
	{
		ListNode*res = new ListNode(0);
		ListNode* temp=res;
		while (l!=NULL&&r!=NULL)
		{
			if (l->val <= r->val)
			{
				temp->next = l;
				temp = temp->next;
				l = l->next;
			}
			else
			{
				temp->next = r;
				temp = temp->next;
				r= r->next;
			}
		}
		if (l!=NULL)
			temp->next = l;
		if (r!=NULL)
			temp->next = r;
		temp = res->next;
		delete res;
		return temp;
	}

	ListNode* mergeSort(ListNode* head)
	{
		if (head->next == NULL)return head;
		ListNode* fast=head, *slow=head, *pre=NULL;
		ListNode* l, *r;
		while (fast != NULL&&fast->next != NULL)
		{
			fast = fast->next->next;
			pre = slow;
			slow = slow->next;
		}
		pre->next = NULL;//断开，一条链变成两条
		l = mergeSort(head);
		r = mergeSort(slow);
		return merge(l, r);
	}
public:
	ListNode* sortList(ListNode* head)
	{
		if (head == NULL || head->next == NULL)
			return head;
		return mergeSort(head);
	}
};

猜你喜欢