C语言八大排序算法，一文带你弄清所有

目录

C语言八大排序

1、插入排序

2、希尔排序

3、简单选择排序

4、堆排序

5、冒泡排序

6、快速排序

7、归并排序

8、基数排序

时间，空间复杂度，以及稳定性对比总结

一些常见题目：

---

C语言八大排序

前言：感谢各位老前辈的写的算法解析，下面的图解也是由网上很多老前辈的图，收下我的膝盖。

 

代码全部由我实测，全都是能用的，不存在不能用的。

 

如果理解不了思想，代码中我凭着自己的理解加了一些注释，清细看，如果还不懂，建议搜索这个排序的详解。

 

写着这篇博客，一方面是自己搞懂八大排序的一个过程，也希望能够帮助到目前的你

 

如果有错，还请指正

 

 

1、插入排序

将第一个和第二个元素排好序，然后将第3个元素插入到已经排好序的元素中，依次类推（插入排序最好的情况就是数组已经有序了）

 

#include 
using namespace std;
typedef long long ll;


void print(int a[], int n,int i)
{
   cout<

 

 

2、希尔排序

因为插入排序每次只能操作一个元素，效率低。元素个数N，取奇数k=N/2，将下标差值为k的数分为一组（一组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为一组，构成有序序列，直到k=1，然后再进行直接插入排序 。

 

 

以一个整数序列为例来说明{12,45,90,1,34,87,-3,822,23,-222,32}，该组序列包含N=11个数。不少已有的说明中通常举例10个数，这里说明一下，排序算法与序列元素个数无关！

首先声明一个参数：增量gap。gap初始值设置为N/2。缩小方式一般为gap=gap/2.

第一步，gap=N/2=5，每间隔5个元素取一个数，组成一组，一共得到5组：

 

对每组使用插入排序算法，得到每组的有序数列：

 

 

至此，数列已变为：

 

第二步，缩小gap，gap=gap/2=2，每间隔2取一个数，组成一组，共两组：

 

同理，分别使用插入排序法，得到每组的有序数列：

 

至此，数列已变为：

 

第三步，进一步缩小gap，gap=gap/2=1，此时只有一组，直接使用插入排序法，玩完成排序，图略。

 

 

#include 
using namespace std;
typedef long long ll;


void ShellSort(int arr[],int N)
{
    int i,j,gap;
    for(gap = N/2;gap>0;gap/=2)
    {
        // 每组进行插入排序
        for(i=0;i=0;j-=gap)
            {
                if(arr[i]>arr[j])
                    break;
            }
            int temp = arr[i];//及记录这个位置
            for(int k=i;k>j;k-=gap)//
                 arr[k] = arr[k-gap];
            arr[j+gap] = temp;
        }
        // 打印当前的gap和序列状态
        cout<<"\ngap="<

 

 

 

 

 

3、简单选择排序

选出最小的数和第一个数交换，再在剩余的数中又选择最小的和第二个数交换，依次类推

#include
using namespace std;


typedef long long ll;


int main()
{
    int a[] = {2,3,7,3,40,34,6};
    int size = sizeof(a)/sizeof(int);
    for(int i=0;ia[j])
                mn = j;
        }
        if(mn!=i)
            swap(a[mn],a[i]);
    }
    for(int i=0;i

 

4、堆排序

推荐慕课上

利用大根堆的性质（堆顶元素最小）不断输出最大元素，直到堆中没有元素

给定一个整形数组a[]={16,7,3,20,17,8}，对其进行堆排序。

首先根据该数组元素构建一个完全二叉树，得到

 

 

 然后需要构造初始堆，则从最后一个非叶节点开始调整对应的代码for(i=size/2;i>=1;i--) ，之后i--,是之后的非叶子结点，调整过程如下：

首先因为总共有6个结点，所以第3个结点也就是最后一个非叶子结点，就是结点值为8开始和它的左孩子和右孩子进行比较，选出最大的在父节点。之后就是结点值为7的和它的左右孩子进行比较，以此类推

 

这样这个堆就建立好啦

 

然后取出最大值和最小值进行交换位置，再次把这个堆重新变成最大堆，怎样变成最大堆呢？？

此时的根节点为最小值，和它的左孩子右孩子进行比较，取最大值交换，继续想下一层去找左孩子和右孩子去比较，直到找不到比它小为止。

至此，完成排序

。对于n个关键字序列，最坏情况下每个节点需比较log2(n)次，因此其最坏情况下时间复杂度为nlogn。堆排序为不稳定排序，不适合记录较少的排序。

 

 

#include
using namespace std;


void HeapAdjust(int *a,int i,int size)  //调整堆
{
    int lchild=2*i;       //i的左孩子节点序号
    int rchild=2*i+1;     //i的右孩子节点序号
    int max=i;            //临时变量，记录父节点
    if(i<=size/2)          //如果i是叶节点就不用进行调整
    {
        //如果左子树大于这父节点
        if(lchild<=size&&a[lchild]>a[max])
        {
            max=lchild;
        }
        //如果右子树大于（左子树和父节点中比较大的值）
        if(rchild<=size&&a[rchild]>a[max])
        {
            max=rchild;
        }
        //如果右孩子的
        if(max!=i)//说明该有孩子节点会比父节点的值大
        {
            swap(a[i],a[max]);
            //继续向下遍历如果它的左孩子和右孩子比它大，再次交换
            HeapAdjust(a,max,size);    //避免调整之后以max为父节点的子树不是堆
        }
    }
}


void BuildHeap(int *a,int size)    //建立堆
{
    int i;
    for(i=size/2;i>=1;i--)    //非叶节点最大序号值为size/2，并且向上遍历非叶子结点
    {
        HeapAdjust(a,i,size);
    }
}


void HeapSort(int *a,int size)    //堆排序
{
    int i;
    BuildHeap(a,size);
    for(i=size;i>=1;i--)
    {
        //cout<

 

 

5、冒泡排序

 

冒泡排序应该不用多说，应该都会把

相邻的两个数进行比较，一趟下来最大的在最右边

进行的是n-1趟之后，便就排序好

废话不多说上图

 

#include
using namespace std;
typedef long long ll;
int main()
{
    int a[] = {4,3,2,0,7,9,2};
    int size = sizeof(a)/sizeof(int);
    for(int i=0;ia[j+1])
                swap(a[j],a[j+1]);//交换
        }
    }
    for(int i=0;i

 

 

6、快速排序

 

选择一个基准元素，比基准元素小的放基准元素的前面，比基准元素大的放基准元素的后面，这种动作叫分区，每次分区都把一个数列分成了两部分，每次分区都使得一个数字有序，然后将基准元素前面部分和后面部分继续分区，一直分区直到分区的区间中只有一个元素的时候，一个元素的序列肯定是有序的嘛，所以最后一个升序的序列就完成啦。

 

实现具体：选择第一个数为基准，安排两个哨兵，一个最左边，一个最右边，  开始 最右边 的向左跑，直到遇见比它小的数停止， 左边的向右跑，直到遇到比它大的数停止，两个哨兵停止，相互交换值，直到两个哨兵碰到一起后，基准与碰到一起的那个位置的值进行交换，之后这个两边的两个区间进行相同的操作。

详情请见：

快速排序

#include 
using namespace std;


void quickSort(int left, int right, int arr[])


{
    if(left >= right)
        return;
    int i, j, base, temp;
    i = left, j = right;
    base = arr[left];  //取最左边的数为基准数
    while (i < j)
    {
        //右边的哨兵开始向左遍历，直到遇见比基准值小的
        while (arr[j] >= base && i < j)
            j--;
        //左边哨兵开始向右边遍历，直到遇见比基准值大的
        while (arr[i] <= base && i < j)
            i++;
        if(i < j)//两个哨兵交换值
        {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    //基准数归位
    arr[left] = arr[i];//最左边的数（基准值）等于停止位置的值
    arr[i] = base;//停止的位置等于基准值
    quickSort(left, i - 1, arr);//递归左边
    quickSort(i + 1, right, arr);//递归右边
}
int main()
{


    int a[] = {10,3,4,6,9,7,4};
    int size = sizeof(a)/4;
    quickSort(0,size-1,a);
    for(int i=0;i

 

 

 

7、归并排序

将一个无序的数列一直一分为二，直到分到序列中只有一个数的时候，这个序列肯定是有序的，因为只有一个数，然后将两个只含有一个数字的序列合并为含有两个数字的有序序列，这样一直进行下去，最后就变成了一个大的有序数列

 

图解：

 

#include 


void MergeArr(int* src,int * tmp,int start,int mid,int end)
{
    int i = start;//前半部分
    int j = mid + 1;//后半部分
    int k = start;
    while (i != mid + 1 && j != end + 1) //进行合并
    {
        if (src[i] < src[j])
            tmp[k++] = src[i++];
        else
            tmp[k++] = src[j++];
    }
    if (i == mid + 1)
    {
        while (j != end+1)
        tmp[k++] = src[j++];
    }
    else
    {
        while (i != mid + 1)
            tmp[k++] = src[i++];
    }
    while (start <= end)//这是把排好序的数组存回去
    {
        src[start] = tmp[start];
        start++;
    }
}


void MergeSort(int* arr, int * tmp,int start,int end)  //归
{
    if (start < end)
    {
        int mid = (start + end) / 2;
        MergeSort(arr, tmp,start,mid);//开始分割，前半部分
        MergeSort(arr, tmp, mid+1, end);//后半部分
        MergeArr(arr, tmp, start, mid, end);//进行合并
    }
}


int main()
{
    int a[8] = { 2,4,5,9,1,6,7,8 };
    int c[8] = {0};
    MergeSort(a, c, 0, 7);
    for (int i = 0; i < 8; i++)
    {
        printf("%d\t", c[i]);
    }
    return 0;
}

 

 

8、基数排序

 

（1）假设有欲排数据序列如下所示：

73  22  93  43  55  14  28  65  39  81

首先根据个位数的数值，在遍历数据时将它们各自分配到编号0至9的桶（个位数值与桶号一一对应）中。

分配结果（逻辑想象）如下图所示：

分配结束后。接下来将所有桶中所盛数据按照桶号由小到大（桶中由顶至底）依次重新收集串起来，得到如下仍然无序的数据序列：

 

81  22  73  93  43  14  55  65  28  39

 

接着，再进行一次分配，这次根据十位数值来分配（原理同上），分配结果（逻辑想象）如下图所示：

分配结束后。接下来再将所有桶中所盛的数据（原理同上）依次重新收集串接起来，得到如下的数据序列：

 

14  22  28  39  43  55  65  73  81  93

 

观察可以看到，此时原无序数据序列已经排序完毕。如果排序的数据序列有三位数以上的数据，则重复进行以上的动作直至最高位数为止。

#include
using namespace std;


#define Max_ 10      //数组个数
#define RADIX_10 10    //整形排序
#define KEYNUM_31 10     //关键字个数，这里为整形位数


// 打印结果
void Show(int  arr[], int n)
{
    int i;
    for ( i=0; i

时间，空间复杂度，以及稳定性对比总结

一些常见题目：

如果只想得到1000个元素组成的序列中第5个最小元素之前的部分排序的序列,用()方法最快

• 起泡排序

• 快速排序

• 希尔排序

• 堆排序

• 简单选择排序

一般这种求前元素中前几个最小或者最大的元素，一般都是选择堆排序