快排（递归的，非递归的）从左往右的，从中间开始的随机的开始方式，链表的快排

#include<iostream>
#include<vector>
#include<list>
#include<stack>
#include<queue>

using namespace std;
// 快排 ， 归并 ， 堆排 //
// 0(nlngn); S(1); // // 
// 
// 
typedef int ElemType;
typedef	struct ListNode
{
	ElemType data;
	struct ListNode* next;
}ListNode,*LinkList;

void ListQuickParition(ListNode* head, ListNode* end)//单链表的快速排序
{
	ListNode* p = head;
	ListNode* s = head->next;
	ElemType tmp = s->data;
	while (s != end)
	{
		if (tmp >= s->data)
		{
			p = p->next;
			swap(p->data, s->data);
		}
		s = s->next;
	}
	swap(head->next->data, p->data);
	ListQuickParition(head, p);
	ListQuickParition(p, end);
}
int LeftParition(int* br, int left, int right)//从左向右的快排
{
	int j = left - 1;
	int i = left;
	int tmp = br[left];
	while (i <= right)
	{
		if (br[i] <= tmp)
		{
			j += 1;
			swap(br[j], br[i]);
		}
		i++;
	}
	swap(br[left], br[j]);
	return j;
}
void Print_Ar(const int* br, int n)
{
	if (br == NULL || n < 1) return;
	for (int i = 0; i < n; ++i)
	{
		cout << br[i] << " ";
	}
	cout << endl;
}

int Parition(int* br, int left, int right)
{
	int tmp = br[left];
	while (left < right)
	{
		while (left < right && br[right] > tmp)
		{
			right--;
		}
		if (left < right)br[left] = br[right];
		while (left < right && br[left] <= tmp)
		{
			left++;
		}
		if (left < right)br[right] = br[left];
	}
	br[left] = tmp;
	return left;
	
}
void PassQuick(int* br, int left, int right)//快排，递归
{
	if (left < right)
	{
		int pos = LeftParition(br, left, right);
		PassQuick(br, left, pos-1);
		PassQuick(br, pos + 1, right);
	}
}
void Quick(int* br, int n)
{
	if (br == NULL || n < 2)return;
	PassQuick(br,0,n-1);
}
int RandParition(int* br, int left, int right)
{
	srand(time(NULL));
	int pos = rand()%(right - left + 1) + left;
	std::swap(br[left], br[pos]);
	return Parition(br, left, right);
}
void QuickSort1(int* br, int n)//快排非递归
{
	if (br == NULL || n < 2)return;
	queue<int> qu;
	qu.push(0);
	qu.push(n - 1);
	while (!qu.empty())
	{
		int left = qu.front();qu.pop();
		int right = qu.front();qu.pop();
		int pos = Parition(br, left,right);
		if (left < pos - 1)
		{
			qu.push(left);
			qu.push(pos - 1);
		}
		if (right > pos + 1)
		{
			qu.push(pos + 1);
			qu.push(right);
		}
	}
}
void QuickSort(int* br, int n)
{
	if (br == NULL || n < 2) return;
	typedef std::pair<int, int> Pair;
	queue<Pair> qu;
	qu.push(Pair(0, n - 1));

	while (!qu.empty())
	{
		Pair pos = qu.front(); qu.pop();
		int mid = RandParition(br, pos.first, pos.second);
		if (pos.first < mid - 1)
		{
			qu.push(Pair(pos.first, mid - 1));
		}
		if (mid + 1 < pos.second)
		{
			qu.push(Pair(mid + 1, pos.second));
		}
	}
}
int MidParition(int* br, int left, int right)//三位去中法
{
	int mid = (right - left) / 2 + left;
	struct IndexNode
	{
		int key;
		int index;

		operator int()const { return key; };
	};
	struct IndexNode kL = { br[left],left };
	struct IndexNode kM = { br[mid],mid };
	struct IndexNode kR = { br[right],right };
	std::priority_queue<IndexNode> hp;
	hp.push(kL);hp.push(kM);hp.push(kR);
	hp.pop();
	struct IndexNode pos = hp.top();

	std::swap(br[kL.index], br[kM.index]);
	return Parition(br, left, right);
}

void Copy(int* src, int* dest, int left, int right)
{
	while (left <= right)
	{
		dest[left] = src[left];
		left++;
	}
}
void Merge(int* src, int* dest, int left, int m, int right)
{
	int i = left, j = m + 1;
	int k = left;
	while (i <= m && j <= right)
	{
		dest[k++] = src[i] <= src[j] ? src[i++] : src[j++];
	}
	while (i <= m)
	{
		dest[k++] = src[i++];
	}
	while (j <= right)
	{
		dest[k++] = src[j++];
	}
}
void MergePass(int* src, int* dest, int left, int right)
{
	if (left < right)
	{
		int mid = (left + right) / 2;
		MergePass(src, dest, left, mid);
		MergePass(src, dest, mid + 1, right);

		Merge(src, dest, left, mid, right);
		Copy(dest, src, left, right);
	}
}
void MergeSort(int* br, int n)//归并排序
{
	if (br == NULL || n < 2)return;
	int* tmp = new int[n];
	MergePass(br, tmp, 0, n-1);

	delete[]tmp;

}
int FindK(int* br, int left, int right,int k)
{
	if (left == right && k == 1)return br[left];
	int pos = Parition(br, left, right);
	int j = pos - left + 1;
	if (k <= j)return FindK(br, left, pos, k);
	else return FindK(br, pos + 1, right, k - j);
}
int Find_Min(int* br, int n,int k)//找这个数组里面的第几小
{
	if (br == NULL || k < 0 || k > n ) return -1;
	return FindK(br, 0, n - 1, k);
}
#if 0
int main()
{
	int ar[] = { 56,12,78,90,34,23,100,56,45,67,89 };
	int n = sizeof(ar) / sizeof(ar[0]);
	Print_Ar(ar, n);
	Quick(ar, n);
	Print_Ar(ar, n);
	return 0;
}
#endif