排序算法总结

一.交换排序

1.冒泡排序

时间复杂度度（O(n^2)），不稳定的排序算法。

排序思想：
比较数列相邻的两个元素大小，如果位置小的元素值大于位置大的元素值，则交换两个元素的位置。

void BubbleSort(int a[],const int  & iSize)
{
	int i, j;
	int iTempValue = 0;
	for (i = 0; i < iSize; ++i)
		for (j = 1; j < iSize - i; ++j)
			if (a[j] < a[j - 1])
			{
				iTempValue = a[j];
				a[j] = a[j - 1];
				a[j - 1] = iTempValue;
			}
}

2.快速排序

对冒泡排序改进的一种排序算法，是目前各种内部排序方法中较快的方法。
时间复杂度：O(nlog(n))，在初始化数列基本有序时，快排序反而退化为冒泡排序。不稳定的排序方法。

排序思想：

1. 指定数列中一个数为基准值，根据基准值对数列进行分割，小于基准数的放左边，大于基准数的放右边；（直到 i = j）
2. 分割完成后，对i 位置的左边和右边元素进行第一步操作排序分割，直到基准值的下标等于i。

void QuickSort(int a[], int s, int iLastPosition)
{
	//s代表基准数的位置  iLastPosition代码最后一个元素的下标
	if (s < iLastPosition)
	{
		int i = s, j = iLastPosition, iValue = a[s];
		while (i < j)
		{
			while (i < j && a[j] >= iValue) // 从右向左找第一个小于基准值的数  
				j--;
			if (i < j)
				a[i++] = a[j];        //把找到的值赋值到i位置，并移动把i指向i+1
			while (i < j && a[i] < iValue) // 从左向右找第一个大于等于基准值的数  
				i++;
			if (i < j)
				a[j--] = a[i];  //把找到的值赋值到j位置，并移动把j指向j-1
		}
		a[i] = iValue;   //把基准值赋值在i位置上
		QuickSort(a, s, i - 1); // 递归调用 在第一趟排序之后  对i左边的数进行排序 
		QuickSort(a, i + 1, iLastPosition);// 递归调用 在第一趟排序之后  对i右边的数进行排序 基准数为a[i+1]
	}
}

二.插入排序

1.希尔排序

时间复杂度： O(n(log2n)^2)

排序思想:

1. 计算增量，一般是除以2，逐步缩小为1。
2. 对每个增量依次进行排序。

void   ShellSort(int  a[],const int & iSize)
{
	int    d = iSize / 2;  //计算第一个增量
	while (d >= 1)
	{
		for (int i = d; i < iSize; ++i)
		{
			int j = i - d;       //j从0开始+1
			int iTemp = a[i];    //记录要插入的数据 
			while (j >= 0 && a[j] > iTemp) //从右向左，找到比其小的数的位置 
			{
				a[j + d] = a[j];  //向后挪动 
				j -= d;
			}

			if (j != i - d) //存在比其小的数
				a[j + d] = iTemp;
		}

		d /= 2;  //下一个增量
	}
}