常用排序方法总结

1.堆排序

void Heapify(vector<int>&res,int i,int size)//从i往下调整堆
{
	int left = 2 * i + 1;
	int right = 2 * i + 2;
	int max = i;
	if (left<size &&res[left]>res[max])
	{
		max = left;
	}
	if (right<size &&res[right]>res[max])
	{
		max = right;
	}
	if (max!=i)
	{
		swap(res[i], res[max]);
		Heapify(res, max, size);
	}
}

void BuildHeap(vector<int> &res, int n)//从下往上建堆
{
	int heap_size = n;
	for (int i = n / 2 - 1; i >= 0;i--)
	{
		Heapify(res, i, n);
	}
}

void HeapSort(vector<int>&res)//堆排序 直到无序区的数量=1
{
	int n = res.size();
	BuildHeap(res,n);
	while (n>1)
	{
		swap(res[0], res[--n]);
		Heapify(res, 0, n);
	}
}

2.快速排序

int Partition(vector<int>&res,int left,int right)    //单路快排
{
	int pivot = res[right];
	int tail = left - 1;
	for (int i = left; i < right;i++)
	{
		if (res[i]<=pivot)
		{
			swap(res[i], res[++tail]);
		}
	}
	swap(res[tail + 1], res[right]);
	return tail+1;
}

int Paritition1(vector<int>&res, int left, int right) //双路快排
{
	int pivot = res[left];
	int i = left + 1;
	int j = right;
	while (true)
	{
		while (res[i] < pivot&&i<right) i++;
		while (res[j] > pivot&&j>left+1) j--;
		if (i>=j) break;
		swap(res[i++], res[j--]);
	}
	swap(res[left], res[j]);
	return j;
}


void quicksort(vector<int>&res,int left,int right)//递归
{
	if (left >= right) return;
	int pivot = Partition(res, left, right);
	quicksort(res, left, pivot - 1);
	quicksort(res, pivot + 1, right);
}

void quicksort1(vector<int>&res)//非递归
{
	stack<int> s;
	s.push(0);
	s.push(res.size()-1);
	while (!s.empty())
	{
		int right = s.top();
		s.pop();
		int left = s.top();
		s.pop();
		int pivot = Partition(res, left, right);
		if (left<pivot-1)
		{
			s.push(left);
			s.push(pivot-1);
		}
		if (pivot+1<right)
		{
			s.push(pivot+1);
			s.push(right);
		}
	}
}

3.归并排序

void merge(vector<int>&res, int start, int mid, int end)
{
	int len = end - start + 1;
	int i = start;
	int j = mid + 1;
	int index = 0;
	vector<int> temp(len);
	while (i<=mid&&j<=end)
	{
		temp[index++] = res[i] <= res[j] ? res[i++] : res[j++];
	}
	while (i<=mid)
	{
		temp[index++] = res[i++];
	}
	while (j<=end)
	{
		temp[index++] = res[j++];
	}
	for (int k = 0; k < len;k++)
	{
		res[start++] = temp[k];
	}
}

void MergeSort(vector<int>&res,int left,int right)//递归
{
	if (left == right)
	{
		return;
	}
	int mid = left + (right - left) / 2;
	MergeSort(res, left, mid);
	MergeSort(res, mid+1, right);
	merge(res, left, mid, right);
}

void MergeSort1(vector<int>&res)//非递归
{
	int len = res.size();
	int start, mid, end;
	for (int i = 1; i < len;i*=2)
	{
		start = 0;
		while (start+i<len)
		{
			mid = start + i -1;
			end = mid + i < len ? mid + i : len - 1;
			merge(res, start, mid, end);
			start = end + 1;
		}
	}
}

4.单链表的快排

struct ListNode
{
	int val;
	ListNode * next;
	ListNode(int val_) :val(val_), next(NULL){}
};

ListNode* Paritition(ListNode *begin, ListNode *end)
{
	int key = begin->val;
	ListNode *p = begin;
	ListNode *q = begin->next;
	while (q!=end)
	{
		if (q->val<key)
		{
			p = p->next;
			swap(p->val, q->val);
		}
		q = q->next;
	}
	swap(p->val, begin->val);
	return p;
}

void quicksort_list(ListNode *begin, ListNode *end)
{
	if (begin!=end)
	{
		ListNode *pivot = Paritition(begin, end);
		quicksort_list(begin, pivot);
		quicksort_list(pivot->next, end);
	}
}