常用排序算法实现（升序）

以下排序算法数组中首位置（下标为零）均不包含源数据（数组从下标为1开始）

简单选择排序

/*************************
简单选择排序
时间复杂度O(n~2)
array 排序数组   n：数组最大下标
*******************/
void selectSort(int* array, int n)
{
	int i, j;//双重循环遍历索引
//外层循环每次将最小值置于最前（最小值->次小值->...）
	for(i=1;i<n;i++)
		for (j = i+1; j <= n; j++)
		{
			if (array[i] > array[j])
			{
				array[0] = array[i];
				array[i] = array[j];
				array[j] = array[0];
			}
		}
}

冒泡排序

/**************************
冒泡排序（设置标识当一次循环中没有发生交换时，说明排序完成，退出循环）
时间复杂度O(n~2)
array 排序数组   n：数组最大下标
*/
void bubbleSort(int* array, int n)
{
	int i, j;
	int flag = 1;
//外层循环每次循环将最大值置于最后
	for (i = 1; i <= n&&flag; i++)
	{
		flag = 0;
		for (j = 1; j <= n - i; j++)
		{
		//相邻两个元素比较大小
			if (array[j] > array[j + 1])
			{
			//交换两元素位置
				array[0] = array[j];
				array[j] = array[j + 1];
				array[j + 1] = array[0];
				flag = 1;//此次循环发生了交换
			}
		}
	}
}

插入排序

/*****************************
直接插入排序
时间复杂度O(n~2）
array 排序数组   n：数组最大下标
****************************/
void insertSort(int *array, int n)
{
	int index;//外层循环
	int aboveIndex;//有序数组末位置下标

	for (index = 2; index <= n; index++)//从数组中第二个数据开始
	{
		array[0] = array[index];	//记录当前比较数据
		aboveIndex = index;//记录当前比较数据的位置
		//aboveIndex之前下标的数据已经有序   
		//将有序数组中从末位置开始所有大于当前比较数据的数后移一位
		while (aboveIndex>=2&&(array[0] < array[aboveIndex-1]))
		{
			array[aboveIndex] = array[aboveIndex-1];
			aboveIndex--;
		}
		//当前比较数据的位置可能被后移数据覆盖 找到了当前比较数据的位置 
		//将array[0]中备份的当前比较数据放入找到的位置中
		array[aboveIndex] = array[0];
	}
}

希尔排序（改进插入排序）

/******************************
希尔排序
时间复杂度O(n~2)
array 排序数组   n：数组最大下标
*****************************/
void shellSort(int* array, int n)
{
	int gap;//每组元素的数量（增量）
	int index;
	int aboveIndex;
//每组元素数量大于等于1时循环
	for (gap = n / 2; gap >=1; gap/=2)
	{
		for (index = gap + 1; index <= n; index++)
		{
			array[0] = array[index];
			aboveIndex = index;
			while ((aboveIndex > gap) && (array[0] < array[aboveIndex - gap]))
			{
				array[aboveIndex] = array[aboveIndex - gap];
				aboveIndex = aboveIndex - gap;
			}
			array[aboveIndex] = array[0];
		}
	}
}

快速排序（改进冒泡排序）

/***************************
快速排序
时间复杂度
array 排序数组   left：数组起始下标 	right：数组结束位置下标
**************************/
void quickSort(int* array, int left,int right)
{
	if (left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
	{
		return;
	}
	int i = left;
	int j = right;
	int key = array[left];

	while (i < j)                               /*控制在当组内寻找一遍*/
	{
		while (i < j && key <= array[j])
			/*而寻找结束的条件就是，1，找到一个小于或者大于key的数（大于或小于取决于你想升
			序还是降序）2，没有符合条件1的，并且i与j的大小没有反转*/
		{
			j--;/*向前寻找*/
		}

		array[i] = array[j];
		/*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是
		a[left]，那么就是给key）*/

		while (i < j && key >= array[i])
			/*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，
			因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/
		{
			i++;
		}

		array[j] = array[i];
	}

	array[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
	quickSort(array, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
	quickSort(array, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
						  /*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/
}

堆排序

    /**********************
堆排序
时间复杂度O(nlogn)
***********************/
//array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度
//本函数功能是：根据数组array构建大根堆
void HeapAdjust(int array[], int i, int nLength)
{
	int nChild;
	for (; 2 * i<=nLength; i = nChild)
	{
		//子结点的位置=2*（父结点位置）+1
		nChild = 2 * i;
		//得到子结点中较大的结点
		if (nChild<nLength && array[nChild + 1]>array[nChild])++nChild;
		//如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点
		if (array[i]<array[nChild])
		{
			array[0] = array[i];
			array[i] = array[nChild];
			array[nChild] = array[0];
		}
		else break; //否则退出循环
	}
}
//堆排序算法
void HeapSort(int array[], int length)
{
	int i;
	//调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素
	//length/2-1是最后一个非叶节点，此处"/"为整除
	for (i = length / 2; i > 0; --i)
		HeapAdjust(array, i, length);
	//从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
	for (i = length; i>1; --i)
	{
		//把第一个元素和当前的最后一个元素交换，
		//保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
		array[i] = array[1] ^ array[i];
		array[1] = array[1] ^ array[i];
		array[i] = array[1] ^ array[i];
		//不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
		HeapAdjust(array, 1, i-1);
	}
}

归并排序

/***************
归并排序
时间复杂度O(m+n)

******************/
void Merge(int sourceArr[], int tempArr[], int startIndex, int midIndex, int endIndex)
{
	int i = startIndex, j = midIndex + 1, k = startIndex;
	while (i != midIndex + 1 && j != endIndex + 1)
	{
		if (sourceArr[i] > sourceArr[j])
			tempArr[k++] = sourceArr[j++];
		else
			tempArr[k++] = sourceArr[i++];
	}
	while (i != midIndex + 1)
		tempArr[k++] = sourceArr[i++];
	while (j != endIndex + 1)
		tempArr[k++] = sourceArr[j++];
	for (i = startIndex; i <= endIndex; i++)
		sourceArr[i] = tempArr[i];
}
//归并排序算法
//sourceArr待排序数组  ；tempArr 临时数组；startIndex 数组开始下标；endIndex 数组结束下标
void MergeSort(int sourceArr[], int tempArr[], int startIndex, int endIndex)
{
	int midIndex;
	if (startIndex < endIndex)
	{
		midIndex = (startIndex + endIndex) / 2;
		MergeSort(sourceArr, tempArr, startIndex, midIndex);
		MergeSort(sourceArr, tempArr, midIndex + 1, endIndex);
		Merge(sourceArr, tempArr, startIndex, midIndex, endIndex);
	}
}