单链表的快排

面试有被问到快排单链表，啊，，这，普通的快排是双指针，一个找比基准值小的，另一个从另一边找比基准值大的，然而单链表只能正向遍历，所以就只采取快排的思想，即分治的思想。
通过查阅资料发现了一种适合单链表的快排。先以数组为列

int i=0;int j=i+1;
int key=0;//基准值
int temp=i;
while(j<n)
{
if(arr[j]>=key)
++j;
else
{
++i;
swap(arr[i],arr[j]);
++j;
}
}
然后再 swap(arr[i],arr[key]);

重复上面的操作
这样做时，j始终找比基准值小的，i始终在比基准值大的前一个位置上（分界点），最终将i上的值与基准值进行交换，这样就使得基准值左边的比它小，右边的比它大。

单链表和数组的思路是一样的，只不过结构不一样哈
代码如下：

#include <iostream>
using namespace std;
struct ListNode 
{
	int val;
	ListNode*next;
	ListNode(int _val=0,ListNode* _next=NULL):val(_val),next(_next)
	{}
	

};

void List_QuickSort(ListNode * qian,ListNode* hou)
{
	//采用分治的思想，找一个基准值，使左边的值都比基准值小，右边的值都比基准值大
	//定义两个指针，一个指针找比基准值小的，另一个的位置标记比基准值大的前一个位置上
	ListNode *i=qian;
	ListNode*j=i->next;
	int temp=i->val;
	while(j!=hou)
	{
		if(j->val<temp)
		{
			i=i->next;
			swap(i->val,j->val);
		}
		j=j->next;
	}
	
	swap(qian->val,i->val);
	if(qian!=i)
	 fast(qian,i);
	if(i->next!=hou)
	  fast(i->next,hou);

}
int main()
{
	ListNode *node1=new ListNode(3);
	ListNode* node2=new ListNode(1);
	ListNode* node3=new ListNode(5);
	ListNode* node4=new ListNode(4);
	ListNode* node5=new ListNode(2);
	ListNode* node6=new ListNode(0);
	
	
	node1->next=node2;
	node2->next=node3;
	
	node3->next=node4;
	
	node4->next=node5;

	node5->next=node6;

	node6->next=NULL;

	ListNode * node=node1;
List_QuickSort(node1,node6->next);
 //打印

while(node)
{
	cout<<node->val<<" " <<endl;
	node=node->next;
}
return 0;
}

运行结果如下