排序算法总结

时间复杂度、空间复杂度

排序算法的分析与实现

1. 冒泡排序
   分析：第 i 趟遍历可以将序列中的第 i 个最大值找到，放到倒数第 i 个位置；
   从第一个位置开始，一趟遍历找最大值，需要每次与后一个相邻位置比较，将较大值后移；

template <typename T>
void BubbleSort(T a[], int len)
{
	int i, j;
	T temp;
	for (j = 0; j < len - 1; j++)//共进行n-1趟排序，最后一个元素为最小的不需要再比较
	{
		for (i = 0; i < len - 1 - j; i++)
			if (a[i] > a[i + 1])//相邻元素进行比较，将较大的元素往后移
			{
				temp = a[i];
				a[i] = a[i + 1];
				a[i + 1] = temp;
			}
	}
}

2. 插入排序
   分析:将第 i 个数在前面已经排好序的 i-1 个数中找合适的位置插入；
   将数后移而不是交换，省去辅助变量节约了时间；

template <typename T>
void InsertSort(T arr[], int len)
{
	if (arr == NULL || len <= 0)
	{
		return;
	}
	T value;
	for (int i = 1; i < len; i++)//默认第一个数有序，则需要插入n-1个数
	{
		value = arr[i];
		for (int j = i - 1; j >= 0; j--)//前i个数有序
		{
			if (value < arr[j])
			{
				arr[j + 1] = arr[j];//将比第i+1个数大的数往后移
				arr[j] = value;
			}
			else
			{
				break;
			}
		}

	}
}

3. 选择排序
   分析:第 1 趟选择第1小数，然后与第一个位置的数交换；
   …；
   第 i 趟选择第i小数，然后与第 i 个位置的数交换；

template<typename T>
void SelectionSort(T arr[],int n) 
{

	int index;// 用来保存最小值得索引
	for (int i = 0; i < 10; ++i)
	{
		index = i; //当前数作为最小数用于比较
		for (int j = i + 1; j < 10; j++)// 寻找第i个小的数值
		{
			if (arr[index] > arr[j])
			{
				index = j;
			}
		}
		T value = arr[index];// 将找到的第i个小的数值放在第i个位置上
		arr[index] = arr[i];
		arr[i] = value;
	}
}

4. 快速排序
   分析：选取序列第一个值作为key，则第一个位置空缺；
   从后往前找第一个小于key的值，放在空缺位置，则第一个小于key的值位置空缺；
   从前往后找第一个大于key的值，放在空缺位置，则第一个大于key的值位置空缺；
   将key填入最后的空缺位置；
   一趟比较后，key的左边均小于key，右边均大于key;
   对key的左边序列、右边序列进行同样的操作。

template <typename T>
void quickSort(T a[], int begin, int end)
{
	if (begin < end)
	{
		T key = a[begin];
		int left = begin, right = end;
		while (left < right)
		{
			while (a[right] > key && left < right)//从后面开始找小于key的值
				right--;
			if (left < right)
			{
				a[left] = a[right];
				left++;
			}

			while (a[left] < key && left < right)//从前面找大于key的值
				left++;
			if (left < right)
			{
				a[right] = a[left];
				right--;
			}
		}
		a[right] = key;
		Sort(a, 0, left - 1);
		Sort(a, left + 1, end);
	}
 }

5. 归并排序
   分析：
   将待排序列分成左右两部分；
   此时左右两部分均有序；（若左右都只有一个数，则为有序数列）
   将有序的左右两部分归并；

void merge(int a[], int begin, int mid, int end, int tmp[])
{
	int i = begin, j = mid + 1;
	int index = 0;
	while (i <= mid && j <= end)//将两部分相同长度部分排好序到tmp[]中
	{
		if (a[i] < a[j])
		{
			tmp[index++] = a[i++];
		}
		else
		{
			tmp[index++] = a[j++];
		}
	}
	while (i <= mid)//若左半部分长，则将剩余元素直接拷贝到tmp[]中
	{
		tmp[index++] = a[i++];
	}
	while (j <= end)//若右半部分长，则将剩余元素直接拷贝到tmp[]中
	{
		tmp[index++] = a[j++];
	}
	for (int i = 0; i < index; i++)//把tmp[0,(index-1)]中已经归并好的元素拷贝到a[begin,end];
	{
		a[begin++] = tmp[i];
	}
}

List item

void mergeSort(int a[], int begin, int end, int tmp[])
{
	if (begin < end)//递归终止的条件
	{
		int mid = (begin + end) / 2;//分解数列
		mergeSort(a, begin, mid, tmp);//左半部分排好
		mergeSort(a, mid + 1, end, tmp);//右半部分排好
		merge(a, begin, mid, end, tmp);//将左右归并到一起
	}
}

6. 希尔排序
   分析：根据增量将数组划分为增量个数列；
   每个数列内部进行插入排序；
   不断缩小增量，使得其为1时，对数组插入排序；（原理是：较为有序的数组进行插入排序，比较移动次数较少，更高效）

void shellSort(int a[], int n)
{
	int add = n / 2;
	while (add >= 1)
	{
		for (int i = 0; i < add; i++)//一趟希尔排序相当于把增量个数列进行插入排序
		{
			for (int j = i + add; j < n; j=j+add)//j直接从第二个带插数列开始，避免插入比较时的index超范围现象
			{
				for (int k = j; k >= i; k = k - add)//k>=i是因为每趟希尔排序开始的初始位置是i
				{
					if (a[k] < a[k - add])
					{
						int tmp = a[k];
						a[k] = a[k - add];
						a[k - add] = tmp;
					}
					else
					{
						break;
					}
				}
			}
		}

		add = add / 2;
	}
}

7. 堆排序
   分析：

9. 桶排序
10. 基排序
    10.计数排序