排序算法

冒泡排序（bubble sort）

void bubble_sort(vector<int>& list)
{
	int size = list.size();
	for (int i = 0; i < size; ++i)
		//for each loop of i, the largest element is put in list[size-i-1]
		for(int j = 0; j < size-i-1; ++j)
			if(list[j] > list[j+1])
				swap(list[j], list[j+1]);
}

选择排序（selection sort）

void selection_sort(vector<int>& list)
{
	int size = list.size();
	int i, j, min_id;
	for (i = 0; i < size-1; ++i)
	{
		min_id = i;
		for (j = i+1; j < size; ++j)
			if(list[j] < list[min_id])
				min_id = j;
		swap(list[i], list[min_id]);
	}
}

插入排序（insertion sort）

void insertion_sort(vector<int>& list)
{
	for(int i = 1; i < list.size(); ++i)
	{
		int temp = list[i];
		int j = i;
		while(j > 0 && temp < list[j-1])
		{
			list[j] = list[j-1];
			--j;
		}
		if(j != i)
			list[j] = temp;

	}
}

归并排序（merge sort）

void merge(vector<int>& list, int l, int m, int r)
{
	vector<int> left(m-l+1);
	vector<int> right(r-m); // r-(m+1)+1

	int i, j;
	for (i = 0; i < (m-l+1); ++i)
		left[i] = list[l+i];
	for (j = 0; j < (r-m); ++j)
		right[j] = list[m+1+j];

	int k = l;
	i = 0;
	j = 0;
	while(i < (m-l+1) && j < (r-m))
	{
		if(left[i] <= right[j])
		{
			list[k] = left[i];
			++i;
		}
		else
		{
			list[k] = right[j];
			++j;
		}
		++k;
	}

	while(i < (m-l+1))
	{
		list[k] = left[i];
		++i;
		++k;
	}

	while(j < (r-m))
	{
		list[k] = right[j];
		++j;
		++k;
	}
}
void __merge_sort(vector<int>& list, int l, int r)
{
	if(l < r)
	{
		int m = l + (r - l) / 2;
		__merge_sort(list, l, m);
		__merge_sort(list, m+1, r);
		merge(list, l, m, r);
	}
}
void merge_sort(vector<int>& list)
{
	__merge_sort(list, 0, list.size()-1);
}

快排（quick sort）

int partition(vector<int>& list, int l, int r)
{
	int i = l - 1;
	int pivot = list[r];
	for(int j = l; j < r; ++j)
	{
		if(list[j] < pivot)
		{
			i++;
			swap(list[i], list[j]);
		}
	}
	swap(list[i+1], list[r]);
	return (i+1);

}
void __quick_sort(vector<int>& list, int l, int r)
{
	if(l < r)
	{
		int pi = partition(list, l, r);
		__quick_sort(list, l, pi-1);
		__quick_sort(list, pi+1, r);
	}
}
void quick_sort(vector<int>& list)
{
	__quick_sort(list, 0, list.size()-1);
}

堆排序（heap sort)

void heapify(vector<int>& list, int size, int id)
{
	int largest = id;
	int left = 2*id + 1;
	int right = 2*id + 2;
	if(left < size && list[left] > list[largest])
		largest = left;
	if(right < size && list[right] > list[largest])
		largest = right;
	if(largest != id)
	{
		swap(list[largest],list[id]);
		heapify(list, size, largest);
	}
}
void __heap_sort(vector<int>& list, int n)
{
	for(int i = n/2-1; i >= 0; i--)
		heapify(list, n, i);
	for(int i = n-1; i >= 0; i--)
	{
		swap(list[0],list[i]);
		heapify(list, i, 0);
	}
}
void heap_sort(vector<int>& list)
{
	__heap_sort(list, list.size());
}