快排非递归：

#include <stdio.h>
#include <stdlib.h>

int partition(int s[], int i, int j)
{
	int value = 0;
	int flag = 1; //判断该从头循环还是尾循环
	value = s[i];
	while(i<j)
	{
		switch(flag)
		{
		case 0:
			if(s[i] < value)
				i++;
			else
			{
				s[j--] = s[i];
				flag = 1;
			}
			break;
		case 1:
			if(s[j] >= value)
				j--;
			else
			{
				s[i++] = s[j];
				flag = 0;
			}
			break;
		}
	}
	s[i] = value;
	return i;
}

void quick_sort(int s[], int l, int r)
{
	int *stack = (int *)malloc(sizeof(int)*(r-l+1));
	int top = 0;
	int index1, index2;
	int res;
	stack[top++] = r;
	stack[top++] = l;
	while(top!=0)
	{
		index1 = stack[--top];
		index2 = stack[--top];
		res = partition(s, index1, index2);

		if(res != index2) //后部分partiton未结束
		{
			stack[top++] = index2;
			stack[top++] = res+1;
		}
		if(res != index1) //前部分partion未结束
		{
			stack[top++] = res-1;
			stack[top++] = index1;
		}
	}
	free(stack);
	stack = NULL;
}

int main()
{
	int number[10] = {8, 1, 8, 4, 9, 5, 8, 10, 3, 6};
	quick_sort(number, 0, 9);
	int i;
	for(i=0; i<10; i++)
	{
		printf("%d, ", number[i]);
	}
	printf("\n");
	return 0;
}

快排递归：

#include <stdio.h>
#include <stdlib.h>

int partition(int s[], int i, int j)
{
	int value = 0;
	int flag = 1; //判断该从头循环还是尾循环
	value = s[i];
	while(i<j)
	{
		switch(flag)
		{
		case 0:
			if(s[i] < value)
				i++;
			else
			{
				s[j--] = s[i];
				flag = 1;
			}
			break;
		case 1:
			if(s[j] >= value)
				j--;
			else
			{
				s[i++] = s[j];
				flag = 0;
			}
			break;
		}
	}
	s[i] = value;
	return i;
}

void quick_sort(int s[], int l, int r)
{
	int res;
	if(l<r)
	{
		res = partition(s, l, r);
		quick_sort(s, l, res-1);
		quick_sort(s, res+1, r);
	}
}

int main()
{
	int number[10] = {8, 1, 8, 4, 9, 5, 8, 10, 3, 6};
	quick_sort(number, 0, 9);
	int i;
	for(i=0; i<10; i++)
	{
		printf("%d, ", number[i]);
	}
	printf("\n");
	return 0;
}

快排另一种形式：(单链表快排)

详见：http://blog.csdn.net/otuhacker/article/details/10366563

struct LNode {
	int key;
	LNode *next;
	LNode(int key):key(key), next(NULL) {}
};

// 两个指针p、q沿next向后遍历，并保证p之前的元素(除首元素外)比key小, p与q之间的元素(除p所指元素外)比key大
// 最后交换首元素和p所指元素的值
LNode *Partition(LNode *begin, LNode *end) {
	int key = begin->key;
	LNode *p = begin;
	LNode *q = begin->next;
	int temp = 0;
	while (q != end) {
		if (q->key < key) {
			p = p->next;
			temp = p->key;
			p->key = q->key;
			q->key = temp;
		}
		q = q->next;
	}
	temp = begin->key;
	begin->key = p->key;
	p->key = temp;
	return p;
}

// 调用时end赋值为NULL
void QuickSort(LNode *begin, LNode *end) {
	if (begin != end) {
		LNode *partition = Partition(begin, end);
		QuickSort(begin, partition);
		QuickSort(partition->next, end);
	}
}

堆排序

#include <iostream>
#include <vector>

using namespace std;

// 堆排序中, 第i个元素的左孩子的标号为2*i,右孩子的标号为2*i+1
// 连续数组中, 如果i从0开始, 则第i个元素的左孩子的标号为2*i+1, 右孩子的标号为2*i+2

void HeapAdjust(vector<int>& nums, int start, int end) {
	int num = nums[start];
	for (int i = 2 * start + 1; i <= end; i = i * 2 + 1) { // 大顶堆
		if (i < end && nums[i] <= nums[i+1])
			i++;
		if (num >= nums[i])
			break;
		nums[start] = nums[i];
		start = i;
	}
	nums[start] = num;
}

void HeapSort(vector<int>& nums) {
	if (nums.size() <= 1) return;

	// 从最后一个非叶子节点开始堆调整，直到根节点截止
	for (int i = nums.size()/2-1; i >= 0; i--) {
		HeapAdjust(nums, i, nums.size()-1);
	}
	for (int i = nums.size()-1; i > 0; i--) {
		// 将堆顶元素(当前最大元素)与数组第i个元素交换,从而使第i大的元素位置固定
		nums[0] = nums[0] ^ nums[i];
		nums[i] = nums[0] ^ nums[i];
		nums[0] = nums[0] ^ nums[i];

		// 重新调整前i个元素为大顶堆
		HeapAdjust(nums, 0, i-1);
	}
}


int main() {
	vector<int> nums;
	int n;
	int val;
	while (cin >> n) {
		for (size_t i = 0; i < n; i++) {
			cin >> val;
			nums.push_back(val);
		}
		HeapSort(nums);

		for (size_t i = 0; i < nums.size(); i++) {
			cout << nums[i] << " ";
		}
		cout << endl;

		nums.clear();
	}
	return 0;
}