排序算法（C++）实现

//选择排序  选择一个固定位置上的值和后面所有位置上的值做比较
void select_sort(int arr[], int len)
{
	//for (int i = 0; i < len - 1; ++i)
	//{
	//	for (int j = i + 1; j < len; ++j)
	//	{
	//		if (arr[i] > arr[j])
	//		{
	//			int temp = arr[i];
	//			arr[i] = arr[j];
	//			arr[j] = temp;
	//		}
	//	}
	//}
	int temp;
	int j;
	for (int i = 0; i < len - 1; ++i)
	{
		for (j = i + 1; j < len; ++j)
		{
			if (arr[i] > arr[j])
			{
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
}
//冒泡  两两相邻位置进行比较
void bubble_sort(int arr[], int len)
{
	int temp;
	int j;
	for (int i = 0; i < len - 1; ++i)
	{
		for (j = 0; j < len - 1 - i; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
//插入
void insert_sort(int arr[], int len)
{
	int temp;
	int j;
	for (int i = 1; i < len; ++i)
	{
		temp = arr[i];//保存下一个待插入的元素
		j = i - 1;
		while (j >= 0 && temp < arr[j])
		{
			arr[j + 1] = arr[j];
			--j;
		}
		arr[j + 1] = temp;
	}
	//int temp;
	//int j;
	//for (int i = 1; i < len; ++i)
	//{
	//	temp = arr[i];//保存下一个待插入的元素
	//	for (j = i - 1; j >= 0 && temp < arr[j]; --j)
	//	{
	//		arr[j + 1] = arr[j];
	//	}
	//	arr[j + 1] = temp;
	//}

	//int temp;
	//int j;
	//for (int i = 1; i < len; ++i)
	//{
	//	temp = arr[i];//保存下一个待插入的元素
	//	for (j = i - 1; j >= 0; --j)
	//	{
	//		if (temp < arr[j])
	//		{
	//			arr[j + 1] = arr[j];
	//		}
	//		else
	//			break;
	//	}
	//	arr[j + 1] = temp;
	//}

	//int temp;
	//int j;
	//for (int i = 1; i < len; ++i)
	//{
	//	for (j = i - 1; j >= 0; --j)
	//	{
	//		if (arr[j + 1] < arr[j])
	//		{
	//			temp = arr[j + 1];
	//			arr[j + 1] = arr[j];
	//			arr[j] = temp;
	//		}
	//		else
	//			break;
	//	}
	//}
}

//希尔排序（可看成由插入排序延伸而来)
void shell_sort(int arr[], int len)
{
	int temp;
	int j;
	int jump = len >> 1;//步长
	while (jump != 0)
	{
		for (int i = jump; i < len; ++i)
		{
			temp = arr[i];//保存下一个待插入的元素
			j = i - jump;
			while (j >= 0 && temp < arr[j])
			{
				arr[j + jump] = arr[j];
				j = j - jump;
			}
			arr[j + jump] = temp;
		}
		jump = jump >> 1;
	}
}

//基数（桶）排序
void radix_sort(int arr[], int len)
{
	int temp[10][10] = {};
	for (int n = 1; n < 10000; n *= 10)//1000表示arr里面最大的数值不会超过1000
	{
		for (int i = 0; i < 10; ++i)
		{
			for (int j = 0; j < 10; ++j)
				temp[i][j] = -1;//初始化，不一定要是-1，只是这个数在待排序数组中没有即可
		}

		for (int i = 0; i < len; ++i)
		{
			int tempIndex = (arr[i] / n) % 10;
			temp[tempIndex][i] = arr[i];
		}

		int k = 0;
		for (int i = 0; i < 10; ++i)
		{
			for (int j = 0; j < 10; ++j)
			{
				if (temp[i][j] != -1)
					arr[k++] = temp[i][j];
			}
		}
	}
}
//快排和归并都是使用递归的排序，两者的效率都很高，
//合并操作
void _merge_in_arr(int arr[], int left, int mid, int right)//用来处理合并
{
	//准备一个辅助数组
	int length = right - left + 1;//确定数组的长度
	int *pData = new int[length];
	//内存逐字节设置值（第1个参数表示内存首地址，第2个参数表示设置的值，第3个参数表示要设置多少个第2个参数）
	memset(pData, 0, sizeof(int)* length);

	//合并
	int low = left;//定义一个变量接住左边下标的值（表示左区间第一个元素的下标）
	int hig = mid + 1;//表示右区间第一个元素的下标
	int index = 0;//表示辅助数组的下标

	while (low <= mid && hig <= right)//并不清楚左区间和右区间的大小,low <= mid表示左区间还有值 hig <= right表示右区间还有值
	{
		while (low <= mid && arr[low] <= arr[hig])//如果左边区间没有越界，且左区间的数值<=右区间的数值 
		{
			pData[index++] = arr[low++];
		}
		while (hig <= right && arr[low] > arr[hig])//如果右边区间没有越界，且右区间的数值<左区间的数值 
		{
			pData[index++] = arr[hig++];
		}
	}

	//到这一步，证明起码有一个区间是合并完成的，接下来把还剩下的区间的数拷贝进辅助数组即可
	if (low <= mid)//证明左区间并没有合并完成，右区间完成了合并
		memcpy(&pData[index],&arr[low],sizeof(int) * (mid -low + 1));//内存拷贝，三个参数，表示把第二个参数做为首地址，拷贝第三个参数大小的数据给到第1个参数
	if (hig <= right)
		memcpy(&pData[index], &arr[hig], sizeof(int)* (right - hig + 1));

	//到这一步，辅助数组里面已经有一个排好序的序列了
	memcpy(&arr[left], pData, sizeof(int)* length);
	delete[]pData;
}
//归并排序
void _merge(int arr[], int left, int right)//通过left和right下标，把arr分成两个逻辑区域
{
	if (left >= right)//当左和右下标一致时，证明这个区间只有一个元素
		return;
	int mid = ((right - left) >> 1) + left;
	_merge(arr, left, mid);//递归左区间
	_merge(arr, mid + 1, right);//递归右区间
	//合并操作
	_merge_in_arr(arr, left, mid, right);
}

//归并
void merge_sort(int arr[], int len)
{
	_merge(arr, 0, len - 1);
}

//快排
void quick_sort(int arr[], int low, int hight)
{
	int t = arr[low];//确定标杆的值
	int f = low + 1;//待确定区域的第一个下标
	int b = hight;//待确定标杆区域的最后一个下标

	if (low >= hight) return;//表示只有一个元素，无需定位
	int tempVal;
	while (f <= b)//待定位的区间存在
	{
		while (f <= b && arr[f] <= t) f++;//f一直找比标杆大的元素
		while (f <= b && arr[b] >= t) b--;//b一直找比标杆小的元素
		if (f < b)//定位区间没有搜索完成
		{
			tempVal = arr[f];
			arr[f] = arr[b];
			arr[b] = tempVal;
			f++;
			b--;
		}
	}
	arr[low] = arr[b];
	arr[b] = t;
	quick_sort(arr, low, b - 1);
	quick_sort(arr, b + 1, hight);
}

以上算法涉及有选择排序，冒泡排序，插入排序，希尔排序，桶排序，归并排序，快速排序，它们的效率是各不相同的，其中冒泡排序的的效率几乎最低，选择排序虽然理论上上与冒泡排序的效率一样，但是实际要快于冒泡排序，桶排序是整型数字排序最快的但是其排序是需要使用大量的空间，所以其空间复杂度较大。下面是一些关于排序算法效率的表格。