C编写基本排序算法及图解

稳定排序：直接插入、冒泡排序、归并排序、基数排序
不稳定排序：选择排序、希尔排序、快速排序、堆排序

排序稳定性：
如果序列中相等的数经过某种算法排序后，仍能保持他们排序前在序列中相对次序，则为稳定。

适用情况：
1、希尔排序、快速排序、堆排序时间复杂度一样，相对而言快速排序最快，堆排序空间消耗少
2、如果待排序列最开始就是基本有序或者局部有序，适用直接插入排序，冒泡排序
3、序列中元素个数少，适用冒泡排序、直接插入排序或选择排序
4、序列规模较大时，适用希尔排序、快速排序、堆排序

插入排序

void insertSort(int array[],int arraySize)
{
	int i,j,tmp;
	for(i = 1; i < arraySize; i ++)	
	{
		tmp = array[i];
		j = i - 1;
		while(j >= 0 && tmp > array[j] )   //从大到小排序
		{
			array[j + 1] = array[j --];     //循环找到array[i]应该放置的位置
		}
		array[j + 1] = tmp;
	}
}

冒泡排序

void bubbleSort(int array[],int arraySize)
{
	int i,j,tmp,flag = 1;
	for(i = 0;i < arraySize -1 &&flag == 1;i ++)
	{
		flag = 0;
		for(j = 0;j < arraySize - i; i ++)
		{
			if(array[j] < array[ + 1])
			{
				tmp = array[j + 1];
				array[j + 1] = array[j];
				array[j] = tmp;
				flag = 1;
			}
		}
	}
}

选择排序

void selectSort(int array[],int arraySize)
{
	int i,j,min,tmp;
	for(i = 0;i < arraySize - 1; i ++)
	{
		min = i;
		for(j = i +1; j < arraySize；j ++)   //在未排序的子序列中找到最小的元素位置
		{
			if(array[j] < array[min])
			{
				min = j;       //记录最小元素位置
			}
		}
		if(min != i)                    //最小元素不位于未排序子序列的第一个位置
		{
			tmp = array[min];
			array[min] = array[i];     //元素交换
			array[i] = tmp;
		}
	}
}

希尔排序

先将整个待排序列划分为若干子序列，分别对子序列进行排序，然后逐步缩小分子序列的间隔，并重复上述操作，直到划分的间隔为1。

void shellSort(int array[],int arraySize)
{
	int i,j,flag,tmp,gap = arraySize;
	while(gap > 1)
	{
		gap = gap/2;          //每次缩小间隔一半
		do                          //子序列可以用冒泡排序
		{
			flag  = 0;
			for(i = 0; i < arraySize - gap;i ++)
			{
				j = i + gap;
				if(array[i] > array[j])
				{
					tmp = array[i];
					array[i] = array[j];
					array[j] = tmp;
					flag = 1;
				}
			}
		}
		while(flag != 0)
	}
}

快速排序

通过一趟排序将待排序列分割为前后两个部分，其中一部分序列中的数据比另一部分序列中的数据小。然后分别对这前后两部分数据进行同样的方法排序。

void quickSortArray(int array[],int s,int t)
{
	int low,high;
	if(s < t)
	{
		low = s;
		high= t +1;
		while(1)
		{
			do low ++;
				while(array[low]  >= array[s] &&low != t);
			do high --;
				while(array[high] <= array[s] &&high != s);
			if(low < high)
			{
				swap(&array[low],&array[high]);
			}
			else
			{
				break;
			}
		}
		swap(&array[s],&array[high]);
		quickSortArray(array,s,high - 1);
		quickSortArray(array,high + 1,t);
	}
}

堆排序

void adjust(int k[],int i,int n)
{
	int j;
	int tmp;
	tmp = k[i  - 1];
	j = i * 2;
	while(j <= n)
	{
		if(j < n &&k[j - 1] > k[j])
		{
			j ++;     //j为i的左右孩子中较小孩子的序号
		}
		if(tmp <= k[j - 1])
		{
			break;
		}
		k[j/2 - 1] = k[j - 1];
		j = 2 * j;
	}
	k[j/2 - 1] = tmp;
}

void heapSort(int k[],int n)
{
	int i,j;
	int tmp;
	for(i = n/2; i >= 1;i --)
	{
		adjust(k,i,n);       //将原序列初始化成
	}
	for(i = n - 1;i >= 0;i --)
	{
		tmp = k[i];
		k[i] = k[0];
		k[0] = tmp;
		adjust(k,1,i);
	}
}