c语言数组常用,常用排序算法总结（简单数组实现，其他类似）----- C语言

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序。若整个排序过程不需

要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问

题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。

我们这里说的是内部排序。

勘误 : 选择排序是不稳定的 !!!

/*

*

*各类排序算法复习(简单数组实现，其他类似)

*Sort Type Review

*2015.11.09

*By Snow Yong

*

*/

#define MINIMUMSIZE 7 //快速排序自定义小数组数目

#define A_LENGTH 10 //数组长度

#include int Swap(int *a, int i, int j);

int BubbleSort(int *a);

int SelectSort(int *a);

int InsertSort(int *a);

int ShellSort(int *a);

int HeapSort(int *a);

int HeapAdjust(int *a, int low, int high);

int MergeSort(int *a);

int Msort(int *S, int *T, int low, int high);

int Merge(int *S, int *T, int low, int m, int high);

int QuickSort(int *a);

int Qsort(int *a, int low, int high);

int Partition(int *a, int low, int high);

int PickMiddle(int *a, int low, int high);

/* Swap Function using to swap element

*元素交换函数

*/

int Swap(int *a, int i, int j)

{

int temp;

temp = a[i];

a[i] = a[j];

a[j] = temp;

}

//BubbleSort -- 冒泡排序 O(n^2)

int BubbleSort(int *a)

{

/*

*flag is using for sort flag

*flag变量用于提高冒泡效率

*/

int i, j, flag = 1;

for (i = 0; i < A_LENGTH-1 && flag; i++)

{

flag = 0;//若flag经 j 循环后为0，则说明序列已然有序

for (j = A_LENGTH-1; j > i; j--)

{

if (a[j] < a[j-1])

{

Swap(a, j, j-1);

flag = 1;

}

}

}

}

//SelectSort -- 选择排序 O(n^2)

int SelectSort(int *a)

{

int i, j, min;

for (i = 0; i < A_LENGTH-1; i++)

{

min = i;

for (j = i+1; j < A_LENGTH; j++)

{

if (a[min] > a[j])

{

min = j;/*不直接交换值，而是记录下标*/

}

}

//若下标不同再一次替换成最小值

if (min != i)

{

Swap(a, min, i);

}

}

}

//InsertSort -- 插入排序 O(n^2)

int InsertSort(int *a)

{

int i, j, temp;

//从第二个数开始循环

for (i = 1; i < A_LENGTH; i++)

{

//满足前提的条件下再记录a[i]的值

if (a[i] < a[i-1])

{

temp = a[i];

for (j = i-1;

a[j] > temp && j >= 0;

j--)

{

a[j+1] = a[j];

}

a[j+1] = temp;/*此处为a[j+1]而不是a[j]是因为上面循环最后执行了j--*/

}

}

}

//ShellSort -- 希尔排序 O(n^(3/2))

int ShellSort(int *a)

{

int i, j, temp;

int increament = A_LENGTH;/*类似插入排序，increament增量处理*/

//跳跃式插入排序

do

{

increament = increament/3 + 1;

for (i = 0+increament; i < A_LENGTH; i++)

{

if (a[i] < a[i-increament])

{

temp = a[i];

for (j = i-increament;

a[j] > temp && j >= 0;

j -= increament)

{

a[j+increament] = a[j];

}

a[j+increament] = temp;

}

}

}

while (increament > 1);

}

//HeapSort -- 堆排序 O(nlogn)

int HeapSort(int *a)

{

int i;

//自行查阅堆和大(小)顶堆的定义

//初始化从中间位置开始构造大顶堆

for (i = A_LENGTH/2 - 1; i >= 0; i--)

{

HeapAdjust(a, i, A_LENGTH-1);

}

//此处一边将最大值选出，一边重新从 0 到 i-1 下标调整大顶堆

for (i = A_LENGTH - 1; i > 0; i--)

{

Swap(a, 0, i);

HeapAdjust(a, 0, i-1);

}

}

//该函数为堆的调整函数(将序列调整为大顶堆), 核心实现函数

int HeapAdjust(int *a, int low, int high)

{

int i, j, temp = a[low];

for (i = 2*low + 1; i <= high; i = 2*i + 1)

{

if (i < high && a[i] < a[i+1])

{

i++;

}/*左右孩子值比较取其较大者*/

if (temp >= a[i])

{//父节点值不小于孩子节点值

break;

}

a[low] = a[i];

low = i;/*不断将下标替换较大值的孩子的下标*/

}

a[low] = temp;

}/*此函数用于调整排序序列为大顶堆*/

//MergeSort -- 归并排序(递归式) O(nlogn)，

//非递归的归并算法请参考博文 ”非递归 -- 归并排序(C语言)“ ，注：一般推荐采用非递归的归并算法

int MergeSort(int *a)

{

Msort(a, a, 0, A_LENGTH-1);

}

int Msort(int *S, int *T, int low, int high)

{

int m;

int T_temp[A_LENGTH];/*辅助数组*/

if (S[low] == S[high])

{

T[low] = S[low];

}

else

{

m = (low + high) / 2;

Msort(S, T_temp, low, m);

Msort(S, T_temp, m+1, high);

Merge(T_temp, T, low, m, high);

}

}

int Merge(int *S, int *T, int low, int m, int high)//归并主要实现函数

{

int j, k, l;/*k用于T数组的下标前进*/

for (k = low, j = m+1;

low <= m && j <= high;

k++)

{

if (S[low] < S[j])

{

T[k] = S[low++];

}

else

{

T[k] = S[j++];

}

}

if (low <= m)

{

for (l = 0; l <= m-low; l++)

{

T[k+l] = S[low+l];

}

}

if (j <= high)

{

for (l = 0; l <= high-j; l++)

{

T[k+l] = S[j+l];

}

}

}

//QuickSort -- 快速排序(已优化) O(nlogn)

int QuickSort(int *a)

{

Qsort(a, 0, A_LENGTH-1);

}

int Qsort(int *a, int low, int high)

{

int pivot;/*枢轴值*/

if ((high - low) > MINIMUMSIZE)

{

while (low < high)

{

pivot = Partition(a, low, high);

Qsort(a, low, pivot-1);

low = pivot + 1;/*此处优化Qsort(a, pivot+1, high)的尾递归*/

}

}

else/*优化小数组的处理方式 -- 变为插入排序效率更高*/

{

InsertSort(a);

}

}

//此处为求枢轴的函数

int Partition(int *a, int low, int high)

{

int temp;

PickMiddle(a, low, high);/*经此函数保证a[low]为较接近中间值*/

temp = a[low];

while (low < high)

{

while (low < high && a[high] >= temp)

{

high--;

}

a[low] = a[high];/*此处优化不必要的交换*/

while (low < high && a[low] <= temp)

{

low++;

}

a[high] = a[low];/*此处优化不必要的交换*/

}

a[low] = temp;

return low;

}

//取接近序列中间大小值并交换给a[low]的函数

int PickMiddle(int *a, int low, int high)

{

int m = (low + high) / 2;

if (a[low] > a[high])

{

Swap(a, low, high);

}

if (a[m] > a[high])

{

Swap(a, m, high);

}

if (a[low] > a[m])

{

Swap(a, low, m);

}

}

int main()

{

int i;

int a[A_LENGTH] = {50, 90, 80, 40, 30,

70, 60, 10, 20, 100};

printf("Before sorting:");

for (i = 0; i < A_LENGTH; i++)

{

printf("%d -- ", a[i]);

}

// BubbleSort(a);

// SelectSort(a);

// InsertSort(a);

// ShellSort(a);

// HeapSort(a);

// MergeSort(a);

QuickSort(a);

printf("\n\nAfter sorting: ");

for (i = 0; i < A_LENGTH; i++)

{

printf("%d -- ", a[i]);

}

return 0;

}

运行结果就不上图了，跟其他排序详解都差不多，因为不喜欢VS卡又慢，所以平台是win + notepad++，编译用的是 MinGW 的 gcc ，因为懒得开虚拟机运行CentOS，

大概结果可参考其他排序算法详解，能力有限，谢谢阅读！

当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；