待字闺中之快排单向链表；leetcode之Sort List

题目来源。待字闺中。原创@陈利人
。欢迎大家继续关注微信公众账号“待字闺中”

分析：思路和数据的高速排序一样，都须要找到一个pivot元素、或者节点。

然后将数组或者单向链表划分为两个部分。然后递归分别快排。

针对数组进行快排的时候，交换交换不同位置的数值。在分而治之完毕之后，数据就是排序好的。那么单向链表是什么样的情况呢？除了交换节点值之外。是否有其它更好的方法呢？能够改动指针，不进行数值交换。这能够获取更高的效率。

在改动指针的过程中。会产生新的头指针以及尾指针，要记录下来。在partition之后，要将小于pivot的的部分、pivot、以及大于pivot的部分又一次串起来成为一个singly
linked list。

在partition时。我们用最后的节点作为pivot。当我们扫描链表时，假设节点值大于pivot，将节点移到尾部之后；假设节点小于。保持不变。

在递归排序时。我们先调用partition将pivot放到正确的为止并返回pivot，然后。递归左边。递归右边。最后在合成一个单链表。

详细代码例如以下：

#include <iostream>
#include <map>
#include <vector>
#include <assert.h>
using namespace std;

struct node
{
int data;
struct node* next;
node(int x):data(x),next(NULL){}
};

node* partition(node* start,node* end,node** newHead,node** newEnd)
{
node* provit = end,*tmp = NULL,*pre = NULL;
while(start != provit)
{
if(start->data > provit->data)
{
tmp = start->next;
if(pre)pre->next = tmp;
start->next = NULL;
end->next = start;
end = start;
start = tmp;
}
else
{
if(*newHead == NULL)*newHead = start;
pre = start;
start = start->next;
}
}
if(*newHead == NULL)*newHead = provit;
*newEnd = end;
return provit;
}
node* GetTail(node* head)
{
if(head == NULL)return NULL;
while(head->next != NULL)head = head->next;
return head;
}
node* QuickSort(node* head,node* end)
{
if(head == NULL || head == end)return head;
node* newHead = NULL,*newEnd = NULL;//此处不能用二维指针。不然partition调用*newHead解引用时会出错
node* provit = partition(head,end,&newHead,&newEnd);
if(newHead != provit)
{
node* tmp = newHead;
while(tmp->next != provit)tmp = tmp->next;
tmp -> next = NULL;
newHead = QuickSort(newHead,tmp);
tmp = GetTail(newHead);
tmp->next = provit;
}
if(provit != newEnd)
{
provit->next= QuickSort(provit->next,newEnd);
}
return newHead;
}
void QuickSort(node** head)
{
if(head == NULL)return;
*head = QuickSort(*head,GetTail(*head));
}
void printLink(node* head)
{
while(head != NULL)
{
cout << head->data <<" ";
head = head->next;
}
cout << endl;
}
int main()
{
int n,i,value;
node* head,*q;
cin >> n;
for(i=0;i<n;i++)
{
cin >> value;
if(i == 0)
{
head = new node(value);
q = head;
}
else
{
node* p = new node(value);
q->next = p;
q = p;
}
}
printLink(head);
QuickSort(&head);
printLink(head);
return 0;
}

leetcode之

Sort List

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

该题用上面的方法会超时，能够使用归并排序

class Solution {
public:
ListNode *sortList(ListNode *head)
{
if(!head || !head->next)return head;
ListNode* fast = head -> next -> next;//至少有两个节点
ListNode* slow = head;
while(fast)
{
fast = fast->next;
slow = slow->next;
if(!fast)break;
fast = fast->next;
}
ListNode* p = slow -> next;
slow -> next = NULL;
ListNode* q = sortList(head);
p = sortList(p);
head = NULL;
ListNode* tail = NULL;
while(q && p)
{
if(q->val > p->val)
{
if(!head)head = tail = p;
else
{
tail->next = p;
tail = tail->next;
}
p = p->next;
}
else
{
if(!head)head = tail = q;
else
{
tail->next = q;
tail = tail->next;
}
q = q->next;
}
}
if(p)
{
if(!head)head = tail = p;
tail->next = p;
}
if(q)
{
if(!head)head = tail = q;
else tail->next = q;
}
return head;
}
};