快排QuickSort （有数组到链表(只需要遍历一次)）

一、数组的快排：

#include<iostream>
#include<vector>
using namespace std;
void swap(int* a, int low, int high)
{
	int temp = 0;
	temp = a[low];
	a[low] = a[high];
	a[high] = temp;
}
void subsort(int* a, int low, int high)
{
	int pivot = a[low];
	int i = low + 1;
	int j = low + 1;
	if (low < high)  //确定终止条件，也不能够越界，最终递归的时候low会大于等于high ->递归的终止条件 
	{
		int pivot = a[low];
		int i = low + 1;
		int j = low + 1;
		while (j <= high)
		{//3 1 2 5 6 7
			if (a[j] < pivot)
			{
				swap(a, i, j);
				i++;
			}
			j++;
		}
	swap(a, low, i - 1);
	subsort(a, 0, i - 1);
	subsort(a, i, high);
	}
}
void quickSort(int* a, int low, int high)
{
	subsort(a, low, high);
}
int main()
{
	int arr[10] = { 0,1,21,10,3,91,5,618,7 ,82};
	swap(arr, 3, 6);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
	cout << "-------------------------" << endl;
	quickSort(arr, 0, 9);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
	return 0;
}

二、链表的快排：

#include<iostream>
#include<vector>
#include<cstdlib>
using namespace std;

class Node;//前向声明
class list;

void SwapNode(Node* a, Node* b);
void SubSort(list& mylist, Node* low, Node* high);
void QuickSort(list& mylist);

class Node
{
public:
	Node(int data,Node*next):data(data),next(next) {}
	int& getdata() { return data; }
	Node*& getnext() { return next; }
private:
	int data;
	Node* next;
};
class list
{
public:
	list()
	{
		headNode = nullptr;
	}
	void insert(int data);//链表的插入
	void printlist()
	{
		Node* pMove=headNode;
		while (pMove != nullptr)
		{
			cout << pMove->getdata()<<"\t";
			pMove = pMove->getnext();
		}
		cout << "\n";
	}
	Node*& GetHead() { return headNode; }
private:
	Node* headNode;
};

void list::insert(int data)
{
	headNode = new Node(data, headNode);
}

int main()
{
	list mylist;
	//mylist.insert(5);
	for (int i = 0; i < 20; i++)
	{
		mylist.insert(rand()/1000);
	}
	cout << "随机生成链表" << endl;
	mylist.printlist();
	cout << endl;
	QuickSort(mylist);
	cout << "快排后:" << endl;
	mylist.printlist();

	return 0;
}

void QuickSort(list& mylist)
{
	//第一步需要得到 链表的尾部 遍历一下链表 O(n) 不怕，快排还要O(nlgn)
	Node* low = mylist.GetHead();
	Node* high = low;
	while (high->getnext() != nullptr) { high = high->getnext(); }
	SubSort(mylist, low, high);
}
void SubSort(list& mylist,Node*low,Node* high)
{
	if(low==nullptr||low->getnext()==nullptr||low==high){return ;}//递归的终止条件
	Node* pivot=low;			//基准点
	Node* i = low->getnext();
	Node* i_pre = low;//用一个指针保存i的前一个节点
	Node* j = low->getnext();
	while (j!= high->getnext ())//注意这边的条件 high->getnext不能用nullptr代替，因为后面的递归就不是null了
	{
		if (j->getdata() < pivot->getdata())//保证i左边的都比pivot小，i-j之间都比pivot大，最后校准pivot的位置
		{
			SwapNode(i, j);
			i_pre = i;
			i = i->getnext();//track the previous Node of i
		}
		j = j->getnext();
	}
	SwapNode(pivot, i_pre);
	SubSort(mylist, low, i_pre);//分治 递归
	SubSort(mylist, i, high);
}
void SwapNode(Node*a,Node*b)  //交换a和b节点中的值域->不打乱原来链表的顺序框架
{
	int temp=a->getdata();
	a->getdata() = b->getdata();
	b->getdata() = temp;
}