各种排序算法

今天总结一下各种排序算法：

N=10000的int数组.

1    插入排序

void insert_sort(int data[], int n)
{
	for(int i = 1; i < n; ++i)
	{
		int key = data[i];
	    int j = i-1;
		while( j >= 0 && data[j] > key )
		{
			data[j+1] = data[j];
			--j;
		}
		data[j+1] = key;
	}
}

耗时：0.054s

2    冒泡排序

void bubble_sort(int data[], int n)
{
	for(int i = 0; i < n-1; ++i)
	{
		for(int j = 0; j < n-1-i; ++j)
		{
			if(data[j] > data[j+1]) swap(data[j], data[j+1]);
		}
	}
}

耗时：2.183s

3  选择排序

void select_sort(int data[], int n)
{
    for(int i = 0; i < n-1; ++i)
	{
		for(int j = i+1; j < n; ++j)
		{
			if(data[i] > data[j]) swap(data[i], data[j]);
		}
	}
}

耗时：2.025s

4  堆排序

void heapify(int data[], int n, int i)
{
	int l = 2*i + 1;
	int r = 2*i + 2;
	int maxid = i;

	if(l < n && data[l] > data[i]) maxid = l;

	if(r < n && data[r] > data[maxid]) maxid = r;

	if(maxid != i)
	{
		swap(data[i], data[maxid]);
		heapify(data, n, maxid);
	}
}

void build_heap(int data[], int n)
{
	for(int i = n/2-1; i >= 0; --i)
	    heapify(data, n, i);
}

void heap_sort(int data[], int n)
{
	build_heap(data, n);

	for(int i = n-1; i >= 1; --i)
	{
		swap(data[0], data[i]);
		heapify(data, i, 0);
	}
}

耗时：0.013s

5    归并排序

void merge(int a[], int lena, int b[], int lenb)
{
	int *res = new int[lena + lenb];

	int i = 0, j = 0, k = 0;

	while(i < lena && j < lenb)
	{
		if(a[i] <= b[j]) res[k++] = a[i++];
		else res[k++] = b[j++];
	}
	while(i < lena) res[k++] = a[i++];
	while(j < lenb) res[k++] = b[j++];

	for(int i = 0; i < lena+lenb; ++i)
		a[i] = res[i];

	delete []res;
}

void merge_sort(int A[],int n)
{
    if(n > 1)
	{
		int mid = n/2;

		merge_sort(A, mid);
		merge_sort(A+mid, n-mid);
		merge(A, mid, A+mid, n-mid);
	}
}

耗时：0.005s not in place

6    快速排序

//quick sort
int partition(int A[], int begin, int end)
{
	int x = A[end];
	int i = begin;
	for(int j = begin; j <= end-1; ++j)
	{
		if(A[j] <= x) swap(A[i++], A[j]);
	}
	swap(A[i], A[end]);

	return i;
}

void quick_sort(int A[], int begin, int end)
{
	if(begin < end)
	{
		int q = partition(A, begin, end);
		quick_sort(A, begin, q-1);
		quick_sort(A, q+1, end);
	}
}

耗时：0.008s in place