C语言常见的四大排序算法--插入排序、选择排序、交换排序、归并排序的实现讲解与性能对比

已于 2024-05-03 09:30:39 修改
阅读量939 收藏 32
点赞数 39
文章标签： 排序算法 c语言 算法
于 2024-05-03 08:49:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74949249/article/details/137831947
版权

文章目录

前言

本文主要介绍四大排序算法以及他们的各自的优化算法，具体优化算法有希尔算法、堆排序、快速插入排序。并求取他们的时间复杂度（这里我们实现的是升序排序）
这里我插入两个链接版本详细介绍堆排序和快速排序（这是我以前写的两个版本）。

一、排序的概念和运用

（一）、排序的概念

  • 排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作
  • 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的，否则称为不稳定的。
  • 内部排序：数据元素全部放在内存中的排序
  • 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能再内外内存之间移动数据的排序。

（二）、排序的实践运用（简单了解一下）

在这里插入图片描述

在这里插入图片描述

二、插入排序

  • 基本思想：把待排序的记录按其关键码值的大小逐
    个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
    这让我联想到了扑克牌：
    在这里插入图片描述
    这就是典型的插入排序。

（一）、直接插入排序（普通版本）

  • 直接插入排序分析：
    这里我们先想一趟的插入排序，将大问题考虑成小问题，这里我们假设从数组下标中0到end是有序的，然后我们的小目标让0到end+1有序，这里我们就用到了while循环，每次比较a[end]与a[end+1]的大小关系，如果a[end]比tmp大的话就实行交换，然后end–，直到end回到0的位置，如果在这期间a[end]的值小于a[end+1]那么就证明已经有序了，我们可以跳出while循环了。 a[end + 1] = tmp;这句代码是我们之前提前记录了新加入比较的数据的值tmp,为了照顾如果比较到了末尾的一刻，或者在中间a[end]就比a[end+1]小，提前退出循环，我们好赋值。完成了一趟插入排序，我们只需要再写一个for循环重复多趟即可完成插入排序。
  • 排序过程如图所示：
    在这里插入图片描述
    直接插入排序元素集合越接近有序，直接插入排序的算法效率越高，这个排序的稳定性较好。
  • 代码函数展示（这里只展示局部代码后面会给出完整代码）
void InsertSort(int* a, int n) {//排的升序;时间复杂度为:(最坏的情况(逆序)):1+2+3+4+...n-1
    //（最好的情况）:顺序
    for (int i = 0;i < n - 1;i++) {//end最终到n-2的数组位置，tmp到数组n-1的位置，数组下标从零开始
        int end=i;
        //[0,end]有序，插入后，[0,end+1]有序
        int tmp = a[end + 1];
        while (end >= 0)
        {
            if (a[end] > tmp)
            {
                a[end + 1] = a[end];//数据往后挪动
                end--;
            }
            else {
                break;
            }
        }
        a[end + 1] = tmp;//比较到末尾的一刻,或者照顾到在中间的情况:当end比tmp小的时候
    }
}

（二）、希尔排序（缩小增量排序）

  • 希尔排序分析：
    希尔排序是对插入排序的优化版本，上面我们上面插入排序的普通版本是间隔为1即a[end]和a[end+1]之间进行比较，为了加快排序效率，我们来改变相比较的间隔，来提升排序效率，这里我们定义间隔为gap,代码转换即将a[end+1]中的1换为gap即a[end+gap]其他代码跟普通版本是一样的，这里我们进行多躺排序，只需要利用while循环让gap一开始赋值为数组的大小，然后不断整除2，进行多趟排序，我们每一躺排序，都会让我们的序列更加有序，每一趟比上一躺花费的时间会更短，最终gap会变成1，即最后进行一趟普通版本的插入排序，这个会很快排好序，因为前面已经进行了多趟排序，让序列逐渐变得有序化。

  • 排序过程如图所示：
    在这里插入图片描述
    希尔排序是对直接插入排序的优化；
    当gap>1的时候都是预排序，目的是让数组更加接近有序。而当gap==1的时候，数组已经接近有序了，这样会排的很快，对整体而言，虽然排的趟数增多了，但是每趟排的时间逐渐缩短，所以最后排序效率会增加。

  • 代码函数展示（这里只展示局部代码后面会给出完整代码）

void ShellSort(int* a, int n) 
{
    //多组间隔为gap的预排序，gap的大小
    //把间隔为gap的数据同时排序
    //gap的取值:
    int gap=n;
    while (gap > 1)
    {
        gap = gap / 2;
        for (int i = 0; i < n - gap; i++)
        {
            int end = i;
            int tmp = a[end + gap];
            while (end >= 0)
            {
                if (a[end] > tmp)
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else {
                    break;
                }
            }
            a[end + gap] = tmp;
        }
    }
}

（三）、两个算法的时间复杂度和空间复杂度分析

  • 直接插入排序（普通版本）：
    时间复杂度：O(N^2)。
    空间复杂度：O（1），这是一种稳定的排序算法。
    稳定性：稳定。

  • 希尔排序：
    平均时间复杂度：O(N ^1.3——N ^2).
    空间复杂度：O(1).
    稳定性：不稳定

（四）、两个算法的完整代码

#include<stdio.h>
#include<stdlib.h>
void Print(int* a, int n) {
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}
void InsertSort(int* a, int n) {//排的升序;时间复杂度为:(最坏的情况(逆序)):1+2+3+4+...n-1
    //（最好的情况）:顺序
    for (int i = 0;i < n - 1;i++) {//end最终到n-2的数组位置，tmp到数组n-1的位置
        int end=i;
        //[0,end]有序，插入后，[0,end+1]有序
        int tmp = a[end + 1];
        while (end >= 0)
        {
            if (a[end] > tmp)
            {
                a[end + 1] = a[end];//数据往后挪动
                end--;
            }
            else {
                break;
            }
        }
        a[end + 1] = tmp;//比较到末尾的一刻,或者照顾到在中间的情况:当end比tmp小的时候
    }
}
void ShellSort(int* a, int n) 
{
    //多组间隔为gap的预排序，gap的大小
    //把间隔为gap的数据同时排序
    //gap的取值:
    int gap=n;
    while (gap > 1)
    {
        gap = gap / 2;
        for (int i = 0; i < n - gap; i++)
        {
            int end = i;
            int tmp = a[end + gap];
            while (end >= 0)
            {
                if (a[end] > tmp)
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else {
                    break;
                }
            }
            a[end + gap] = tmp;
        }
    }
}
void InsertSorttest()
{
int a[] = { 1,9,8,6,5,44,12,33,15 };
InsertSort(a,sizeof(a) / sizeof(int));
Print(a,sizeof(a)/sizeof(int));
}
void ShellSorttest()
{
 int a[] = { 1,9,8,6,5,44,12,33,15 };
 ShellSort(a, sizeof(a) / sizeof(int));
 Print(a,sizeof(a)/sizeof(int));
}
int main()
{
InsertSorttest();//插入排序普通版本
ShellSorttest();//希尔排序
return 0;
}

三、选择排序

  • 基本思想：每一次从待排序的数据中选出最小(或者最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素全部排完。

（一）、直接选择排序（普通版本）

  • 选择排序普通版本分析：
    过程分析：在元素集合a[i]–a[n-1]中选择关键码最大（小）的元素；若他不是这组元素的最后一个（第一个）元素，则将她与这组元素中的最后一个（第一个）元素交换；在剩余a[i]–a[n-2]集合中，重复上述步骤，直到剩余一个元素。
    这里我们做一个小的算法优化，在a[i]到a[n-1]个元素序列中我让关键码定为两个，一个代表最大，一个代表最小，如果最小的关键码不是第一个，则与序列的第一个元素交换，如果最大关键码不是最后一个元素，则与最后一个元素进行交换。在剩余a[i+1]到a[n-2]个元素序列中，重复以上步骤，直到集合剩余1个元素。这样会增加排序的效率

  • 排序过程如图所示：
    在这里插入图片描述
    直接选择排序思考过程很简单，但是效率不是很好，实际生活中很少使用

  • 代码函数展示（这里只展示局部代码后面会给出完整代码）

void Swap(int* p1, int* p2)//交换两个数的位置函数
{
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;


}
void SelectSort(int* a, int n)//时间复杂度（O(N*N)）
{
    int begin = 0;
    int end = n - 1;

    while(begin<end)
    {
        int mini = begin;
        int maxi = begin;
        for (int i = begin; i <= end; i++)
        {

            if (a[i] < a[mini])
            {
                mini = i;
            }
            if (a[i] > a[maxi])
            {
                maxi = i;
            }
            Swap(&a[begin], &a[mini]);
            if (begin == maxi)//避免出现bUg
            {
                maxi = mini;
            }
            Swap(&a[end], &a[maxi]);
        }
        begin++;
        end--;  
    }
}

（二）、堆排序

（三）、两个算法的时间复杂度和空间复杂度分析

  • 直接选择排序（普通版本）：
    时间复杂度：O（N^2）
    空间复杂度：O(1)
  • 堆排序：
    时间复杂度:O(N*logN)
    空间复杂度：O(1)

（四）、两个算法的完整代码

#include<stdio.h>
#include<stdlib.h>
void Print(int* a, int n) {
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}
void Swap(int* p1, int* p2)//交换两个数的位置函数
{
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}
void SelectSort(int* a, int n)//时间复杂度（O(N*N)）
{
    int begin = 0;
    int end = n - 1;
    while(begin<end)
    {
        int mini = begin;
        int maxi = begin;
        for (int i = begin; i <= end; i++)
        {

            if (a[i] < a[mini])
            {
                mini = i;
            }
            if (a[i] > a[maxi])
            {
                maxi = i;
            }
            Swap(&a[begin], &a[mini]);
            if (begin == maxi)//避免出现bUg
            {
                maxi = mini;
            }
            Swap(&a[end], &a[maxi]);
        }
        begin++;
        end--;
    }
}
void AdjustDown(int* a, int n, int root)//向下调整算法,建堆
//时间复杂度：O(logN)
{
    int parent = root;
    int child = parent * 2 + 1;//(左孩子的公式)
    //通过下标找出父子节点的关系
    //右孩子:rightchild=parent*2+2
    // 左孩子：leftchild=parent*2+1
    // 父亲:parent=(child-1)/2
    //孩子超过数组下标表示结束
    while (child < n)
    {
        if (a[child + 1] > a[child] && child + 1 < n) {
            ++child;
            //让child始终为左右孩子中小的那个
        }
        //小的往上浮，大的往下沉
        if (a[child] > a[parent]) {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else {
            break;
        }
    }
}
void HeapSort(int* a, int n)//(时间复杂度：o(N*logN))
{
    //第一步：建堆（时间复杂度为：O（n））
    //向下调整算法：前提：左右子数都是小堆
    //从根节点开始，选出左右孩子中小的哪一个，跟父亲比较，如果比父亲小就交换，然后再继续往下调，调到叶子节点就终止
    //排升序，要建大堆！！操作：第一个和最后一个交换，把他不看做堆里面。前n-1个数向下调整，选出次大的数，再跟倒数第二个位置交换
    for (int i =(n-1-1)/2 ;i >= 0;--i) {//从倒数第一个非叶子节点开始调整
        AdjustDown(a, n, i);
    }
    //第二步：//排升序，要建大堆！！操作：第一个和最后一个交换，把他不看做堆里面。前n-1个数向下调整，选出次大的数，再跟倒数第二个位置交换
    int end = n - 1;
    while (end>0)
    {
        Swap(&a[0], &a[end]);
        AdjustDown(a, end, 0);
        --end;
    }
}
void SelectSorttest()
{
int a[] = { 3, 5, 2, 7, 8, 6, 1, 9, 4, 0 };
SelectSort(a, sizeof(a) / sizeof(int));
Print(a, sizeof(a) / sizeof(int));
}
void HeapSorttest()
{
 int a[] = { 3, 5, 2, 7, 8, 6, 1, 9, 4, 0 };
 HeapSort(a, sizeof(a) / sizeof(int));
 Print(a, sizeof(a) / sizeof(int));
}
int main()
{
SelectSorttest();//选择排序
HeapSorttest();//堆排序
return 0;
}

四、交换排序

  • 基本思想：所谓交换，就是根据序列中两个记录键值得比较结果来对换这两个记录在序列中得位置，交换排序的特点就是：将键值较大的记录向序列尾部移动，键值较小的记录向序列的前部移动。

（一）、冒泡排序

  • 冒泡排序分析：
    我们利用双重for循环就可以实现该排序，在外重for循环中我们遍历数组下标，在内重循环中，我们让相邻两个数进行比较，小的在前面，大的在后面，如果不是的化我们交换两个位置，直到让大的数落到后面。这样完成一趟外重for循环，紧接着进行多趟外重for循环就可以完成冒泡排序。在这里我们稍微优化了算法，我们定义一个change变量一开始赋值为零，如果在内重循环中我们只要进行了一次交换我们就让change赋值成1，经历了一趟外重循环后，如果change的值没有变，这是我们就可以退出外重循环了因为此时已经有序。

  • 冒泡排序的过程如图所示：
    在这里插入图片描述
    冒泡排序是一种非常好理解的排序，它的稳定性较好。

  • 代码实现（这里只展示部分代码，后面会给出完整代码）

void Swap(int* p1, int* p2)//交换两个数的位置函数
{
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}
void BubbleSort(int* a, int n)
//冒泡排序（交换排序）
{
    for (int i = 0; i < n; i++)
    {
        int change = 0;
        for (int j = 1; j <n-i ; j++)
        {
            if (a[j - 1] > a[j]) {
                Swap(&a[j - 1], &a[j]);
                change = 1;
            }
        }
        if (change == 0)//如果冒完一遍后没有交换的现象，那么就证明有序了，后面就不需要再进行冒泡了
        {
            break;
        }
    }
}

（二）、快速排序

（三）、两个算法的时间复杂度和空间复杂度分析

  • 冒泡排序：
    时间复杂度：O(N^2)
    空间复杂度：O(1)
    稳定性：稳定

  • 快速排序：
    时间复杂度：O(N*logN)
    空间复杂度: O(logN)~O(N)
    稳定性：不稳定

（四）、两个算法的完整代码

#include<stdio.h>
#include<stdlib.h>
void Print(int* a, int n) {
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}
void Swap(int* p1, int* p2)//交换两个数的位置函数
{
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}
void BubbleSort(int* a, int n)//冒泡排序（交换排序）
{
    for (int i = 0; i < n; i++)
    {
        int change = 0;
        for (int j = 1; j <n-i ; j++)
        {
            if (a[j - 1] > a[j]) {
                Swap(&a[j - 1], &a[j]);
                change = 1;
            }
        }
        if (change == 0)
        {
            break;
        }
    }
}
int GetMidIndex(int* a, int left, int right)//三数取中
{
    int mid = (left + right) >> 1;//等效于整除于2
    if (a[left] < a[mid])
    {
        if (a[mid] < a[right])
        {
            return mid;
        }
        else if (a[left] > a[right])
        {
            return left;
        }
        else
        {
            return right;
        }
    }
    else//a[left]>=a[mid]
    {
        if (a[mid] > a[right])
        {
            return mid;
        }
        else if (a[left] < a[right])
        {
            return left;
        }
        else
        {
            return right;
        }
    }
}
//利用挖洞法来进行快速排序
int Part1Sort(int* a, int left, int right)//实现分治递归//时间复杂度：O（N*log(N))
{
    //三数取中法，如果一开始为有序时候，为了降低时间复杂度(将begin赋予整体数据较为靠中数据的下标值)
    int index = GetMidIndex(a, left, right);
    Swap(&a[left], &a[index]);
    //第一趟排序：
    int begin = left, end = right;
    int pivot = begin;//让洞的位置为最开始位置
    int key = a[begin];
    while (begin < end)
    {
        //从最右面开始找比key小的数，放到左面
        while (begin < end && a[end] >= key)//注意begin<end要加上防止比的超出界限，a[end]>=key要加上等于防止出现死循环BUG
        {
            --end;
        }
        //小的数据放在左边的坑位，自己的位置形成新的坑位
        a[pivot] = a[end];
        pivot = end;
        //从最左面开始找比key大的数，放在右面
        while (begin < end && a[begin] <= key)
        {
            ++begin;
        }
        //大的数据放在右边的坑位，自己的位置形成新的坑位
        a[pivot] = a[begin];
        pivot = begin;
    }
    //最后将begin或者end(此两者相等)赋给洞，此时洞的位置即key值自己真实的大小位置
    pivot = begin;
    a[pivot] = key;
    //此时再让左子区间和右子区间分别有序，那么最终就有序了
    //实现方法：分治递归：}
    return pivot;
}
//左右指针法来实现快速排序
int Part2Sort(int* a, int left, int right)//左右指针法来进行快速排序
{
    int index = GetMidIndex(a, left, right);
    Swap(&a[left], &a[index]);
    int begin = left, end = right;
    int keyi = begin;
    while (begin < end)
    {
        //从右边开始找比a[keyi]小的数据
        while (begin < end && a[end] >= a[keyi])
        {
            --end;
        }
        //从左边开始找比a[keyi]大的数据
        while (begin < end && a[begin] <= a[keyi])
        {
            ++begin;
        }
        //从两边分别找到比a[keyi]小的数据和比a[keyi]大的数据，将两数据进行交换
        Swap(&a[begin], &a[end]);
    }
    //将a[keyi]于a[begin]交换或者于a[end]交换，将a[keyi]放在真实大小的位置
    Swap(&a[begin], &a[keyi]);
    return begin;

}
int Part3Sort(int* a, int left, int right)//前后指针法来进行快速排序
{
    int index = GetMidIndex(a, left, right);
    Swap(&a[left], &a[index]);
    int keyi = left;
    int prev = left, cur = left + 1;
    //cur找比a[keyi]小的数，每次遇到比key小的值就停下来，++prev,交换prev和cur位置的值
    while (cur<=right)
    {
        if (a[cur] < a[keyi]&&++prev !=cur)//这里不需要等于，不会出现死循环的BUG
        {
            Swap(&a[prev], &a[cur]);
        }
        ++cur;
    }
    Swap(&a[keyi], &a[prev]);
    return prev;

}
void QuickSort(int* a, int left, int right)//实现分治递归//时间复杂度：O（N*log(N))
{
    if (left >= right)
    {
        return;
    }
    //将左子区间和右子区间变为有序，实现方法：分治递归；
    int keyIndex = Part3Sort(a, left, right);//上面三种方法选择其一即可
    QuickSort(a, left, keyIndex - 1);
    QuickSort(a, keyIndex + 1, right);
}
void BubbleSorttest()
{
 int a[] = { 3, 5, 2, 7, 8, 6, 1, 9, 4, 0 };
 BubbleSort(a, sizeof(a) / sizeof(int));
 Print(a, sizeof(a) / sizeof(int));
}
void QuicktSorttest()
{
int a[] = { 3, 5, 2, 7, 8, 6, 1, 9, 4, 0 };
QuickSort(a, 0, sizeof(a) / sizeof(int)-1);
Print(a, sizeof(a) / sizeof(int));
}
int main()
{
BubbleSorttest();//冒泡排序
QuicktSorttest();//快速排序
return 0;
}

五、归并排序

（一）、 归并排序算法实现分析

  • 基本思想：归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治递归的一种非常典型的应用，将已有序列的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，则称为二路归并。
  • 归并过程如图所示：
    在这里插入图片描述
    在这里插入图片描述
    这里提一点：归并的缺点在于要使用O(N)的空间复杂度，归并排序的思考更多的是解决磁盘中的外排序问题。

（二）、归并排序时间复杂度和空间复杂度分析

  • 时间复杂度：O(N*logN)
  • 空间复杂度：O(N)
  • 稳定性：稳定

（三）、归并排序代码实现

#include<stdio.h>
#include<stdlib.h>
void Print(int* a, int n) {//打印一下数组
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}
void _MergeSort(int* a, int left, int right, int* tmp)
{
    if (left >= right)//递归的限制条件
    {
        return;
    }
    int mid = (left + right) >> 1;//取得中间数字
    _MergeSort(a, left, mid, tmp);//让左区间有序
    _MergeSort(a, mid + 1, right, tmp);//让右区间有序
    int begin1 = left;
    int end1 = mid;
    int begin2 = mid + 1;
    int end2 = right;
    int index = left;
    while (begin1<=end1&&begin2<=end2)
    {
        if (a[begin1] < a[begin2])
        {
            tmp[index++] = a[begin1++];
        }
        else
        {
            tmp[index++] = a[begin2++];
        }
    }
    while (begin1 <= end1)
    {
        tmp[index++] = a[begin1++];
    }
    while (begin2 <= end2)
    {
        tmp[index++] = a[begin2++];
    }
    //拷贝回去
    for (size_t i = left; i <= right; i++)
    {
        a[i] = tmp[i];
    }
}
void MergeSort(int* a, int n)
{
    int left = 0;
    int right = n - 1;
    int* tmp = (int*)malloc(sizeof(int) * n);//开辟新空间数组
    _MergeSort(a, left, right, tmp);
    free(tmp);//释放数组
}
int main() 
{
int a[] = { 3, 5, 2, 7, 8, 6, 1, 9, 4, 0 };
MergeSort(a, sizeof(a) / sizeof(int));
Print(a, sizeof(a) / sizeof(int));
}

六、四大排序算法性能比较

  • 上面提到的7中排序复杂度及稳定性汇总分析：
    如图所示：

在这里插入图片描述

  • 接下来我们利用代码来进行它们之间的性能比较：
  • 代码实现：
#include<stdio.h>
#include<stdlib.h>
void Print(int* a, int n) {
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}
void InsertSort(int* a, int n) {//排的升序;时间复杂度为:(最坏的情况(逆序)):1+2+3+4+...n-1
    //（最好的情况）:顺序
    for (int i = 0;i < n - 1;i++) {//end最终到n-2的数组位置，tmp到数组n-1的位置
        int end=i;
        //[0,end]有序，插入后，[0,end+1]有序
        int tmp = a[end + 1];
        while (end >= 0)
        {
            if (a[end] > tmp)
            {
                a[end + 1] = a[end];//数据往后挪动
                end--;
            }
            else {
                break;
            }
        }
        a[end + 1] = tmp;//比较到末尾的一刻,或者照顾到在中间的情况:当end比tmp小的时候
    }
}
void ShellSort(int* a, int n) 
{
    //多组间隔为gap的预排序，gap的大小
    //把间隔为gap的数据同时排序
    //gap的取值:
    int gap=n;
    while (gap > 1)
    {
        gap = gap / 2;
        for (int i = 0; i < n - gap; i++)
        {
            int end = i;
            int tmp = a[end + gap];
            while (end >= 0)
            {
                if (a[end] > tmp)
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else {
                    break;
                }
            }
            a[end + gap] = tmp;
        }


    }
  

}
void Swap(int* p1, int* p2)//交换两个数的位置函数
{
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;


}
void SelectSort(int* a, int n)//时间复杂度（O(N*N)）
{
    int begin = 0;
    int end = n - 1;

    while(begin<end)
    {
        int mini = begin;
        int maxi = begin;
        for (int i = begin; i <= end; i++)
        {

            if (a[i] < a[mini])
            {
                mini = i;
            }
            if (a[i] > a[maxi])
            {
                maxi = i;
            }
            Swap(&a[begin], &a[mini]);
            if (begin == maxi)//避免出现bUg
            {
                maxi = mini;
            }
            Swap(&a[end], &a[maxi]);
        }
        begin++;
        end--;
       
    }




}
void AdjustDown(int* a, int n, int root)//向下调整算法,建堆
//时间复杂度：O(logN)
{
    int parent = root;
    int child = parent * 2 + 1;//(左孩子的公式)
    //通过下标找出父子节点的关系
    //右孩子:rightchild=parent*2+2
    // 左孩子：leftchild=parent*2+1
    // 父亲:parent=(child-1)/2
    //孩子超过数组下标表示结束
    while (child < n)
    {
        if (a[child + 1] > a[child] && child + 1 < n) {
            ++child;
            //让child始终为左右孩子中小的那个
        }
        //小的往上浮，大的往下沉
        if (a[child] > a[parent]) {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else {
            break;
        }
    }

    



}
void HeapSort(int* a, int n)//(时间复杂度：o(N*logN))
{
    //第一步：建堆（时间复杂度为：O（n））
    //向下调整算法：前提：左右子数都是小堆
    //从根节点开始，选出左右孩子中小的哪一个，跟父亲比较，如果比父亲小就交换，然后再继续往下调，调到叶子节点就终止
    //排升序，要建大堆！！操作：第一个和最后一个交换，把他不看做堆里面。前n-1个数向下调整，选出次大的数，再跟倒数第二个位置交换
    for (int i =(n-1-1)/2 ;i >= 0;--i) {//从倒数第一个非叶子节点开始调整
        AdjustDown(a, n, i);
    }
    //第二步：//排升序，要建大堆！！操作：第一个和最后一个交换，把他不看做堆里面。前n-1个数向下调整，选出次大的数，再跟倒数第二个位置交换
    int end = n - 1;
    while (end>0)
    {
        Swap(&a[0], &a[end]);
        AdjustDown(a, end, 0);
        --end;
    }
}
void BubbleSort(int* a, int n)
//冒泡排序（交换排序）
{
    for (int i = 0; i < n; i++)
    {
        int change = 0;
        for (int j = 1; j <n-i ; j++)
        {
            if (a[j - 1] > a[j]) {
                Swap(&a[j - 1], &a[j]);
                change = 1;
            }
        }
        if (change == 0)
        {
            break;
        }
    }
}
int GetMidIndex(int* a, int left, int right)
{
    int mid = (left + right) >> 1;//等效于整除于2
    if (a[left] < a[mid])
    {
        if (a[mid] < a[right])
        {
            return mid;
        }
        else if (a[left] > a[right])
        {
            return left;
        }
        else
        {
            return right;
        }
    }
    else//a[left]>=a[mid]
    {
        if (a[mid] > a[right])
        {
            return mid;
        }
        else if (a[left] < a[right])
        {
            return left;
        }
        else
        {
            return right;
        }
    }
}
//利用挖洞法来进行快速排序
int Part1Sort(int* a, int left, int right)//实现分治递归//时间复杂度：O（N*log(N))
{
    //三数取中法，如果一开始为有序时候，为了降低时间复杂度(将begin赋予整体数据较为靠中数据的下标值)
    int index = GetMidIndex(a, left, right);
    Swap(&a[left], &a[index]);
    //第一趟排序：
    int begin = left, end = right;
    int pivot = begin;//让洞的位置为最开始位置
    int key = a[begin];
    while (begin < end)
    {
        //从最右面开始找比key小的数，放到左面
        while (begin < end && a[end] >= key)//注意begin<end要加上防止比的超出界限，a[end]>=key要加上等于防止出现死循环BUG
        {
            --end;
        }
        //小的数据放在左边的坑位，自己的位置形成新的坑位
        a[pivot] = a[end];
        pivot = end;
        //从最左面开始找比key大的数，放在右面
        while (begin < end && a[begin] <= key)
        {
            ++begin;
        }
        //大的数据放在右边的坑位，自己的位置形成新的坑位
        a[pivot] = a[begin];
        pivot = begin;
    }
    //最后将begin或者end(此两者相等)赋给洞，此时洞的位置即key值自己真实的大小位置
    pivot = begin;
    a[pivot] = key;
    //此时再让左子区间和右子区间分别有序，那么最终就有序了
    //实现方法：分治递归：}
    return pivot;
}
//左右指针法来实现快速排序
int Part2Sort(int* a, int left, int right)//左右指针法来进行快速排序
{
    int index = GetMidIndex(a, left, right);
    Swap(&a[left], &a[index]);
    int begin = left, end = right;
    int keyi = begin;
    while (begin < end)
    {
        //从右边开始找比a[keyi]小的数据
        while (begin < end && a[end] >= a[keyi])
        {
            --end;
        }
        //从左边开始找比a[keyi]大的数据
        while (begin < end && a[begin] <= a[keyi])
        {
            ++begin;
        }
        //从两边分别找到比a[keyi]小的数据和比a[keyi]大的数据，将两数据进行交换
        Swap(&a[begin], &a[end]);
    }
    //将a[keyi]于a[begin]交换或者于a[end]交换，将a[keyi]放在真实大小的位置
    Swap(&a[begin], &a[keyi]);
    return begin;

}
int Part3Sort(int* a, int left, int right)//前后指针法来进行快速排序
{
    int index = GetMidIndex(a, left, right);
    Swap(&a[left], &a[index]);
    int keyi = left;
    int prev = left, cur = left + 1;
    //cur找比a[keyi]小的数，每次遇到比key小的值就停下来，++prev,交换prev和cur位置的值
    while (cur<=right)
    {
        if (a[cur] < a[keyi]&&++prev !=cur)//这里不需要等于，不会出现死循环的BUG
        {
            Swap(&a[prev], &a[cur]);
        }
        ++cur;
    }
    Swap(&a[keyi], &a[prev]);
    return prev;

}
void QuickSort(int* a, int left, int right)//实现分治递归//时间复杂度：O（N*log(N))
{
    if (left >= right)
    {
        return;
    }
    //将左子区间和右子区间变为有序，实现方法：分治递归；
    int keyIndex = Part3Sort(a, left, right);
    QuickSort(a, left, keyIndex - 1);
    QuickSort(a, keyIndex + 1, right);
}
void _MergeSort(int* a, int left, int right, int* tmp)
{
    if (left >= right)
    {
        return;
    }
    int mid = (left + right) >> 1;//取得中间数字
    _MergeSort(a, left, mid, tmp);//让左区间有序
    _MergeSort(a, mid + 1, right, tmp);//让右区间有序
    int begin1 = left;
    int end1 = mid;
    int begin2 = mid + 1;
    int end2 = right;
    int index = left;
    while (begin1<=end1&&begin2<=end2)
    {
        if (a[begin1] < a[begin2])
        {
            tmp[index++] = a[begin1++];
        }
        else
        {
            tmp[index++] = a[begin2++];
        }
    }
    while (begin1 <= end1)
    {
        tmp[index++] = a[begin1++];
    }
    while (begin2 <= end2)
    {
        tmp[index++] = a[begin2++];
    }
    //拷贝回去
    for (size_t i = left; i <= right; i++)
    {
        a[i] = tmp[i];
    }
}
void MergeSort(int* a, int n)
{
    int left = 0;
    int right = n - 1;
    int* tmp = (int*)malloc(sizeof(int) * n);
    _MergeSort(a, left, right, tmp);
    free(tmp);
}
void testOP()
{
srand(time(0));
const int N = 100000;
int* a1 = (int*)malloc(sizeof(int) * N);
int* a2 = (int*)malloc(sizeof(int) * N);
int* a3 = (int*)malloc(sizeof(int) * N);
int* a4 = (int*)malloc(sizeof(int) * N);
int* a5 = (int*)malloc(sizeof(int) * N);
int* a6 = (int*)malloc(sizeof(int) * N);

for (int i = 0; i < N; ++i)
{
	a1[i] = rand();
	a2[i] = a1[i];
	a3[i] = a1[i];
	a4[i] = a1[i];
	a5[i] = a1[i];
	a6[i] = a1[i];

}

int begin1 = clock();
InsertSort(a1, N);
int end1 = clock();

int begin2 = clock();
ShellSort(a2, N);
int end2 = clock();

int begin3 = clock();
SelectSort(a3, N);
int end3 = clock();

int begin4 = clock();
HeapSort(a4, N);
int end4 = clock();

int begin5 = clock();
QuickSort(a5, 0, N - 1);
int end5 = clock();

int begin6 = clock();
MergeSort(a6, N);
int end6 = clock();

printf("InsertSort:%d\n", end1 - begin1);
printf("ShellSort:%d\n", end2 - begin2);
printf("SelectSort:%d\n", end3 - begin3);
printf("HeapSort:%d\n", end4 - begin4);
printf("QuickSort:%d\n", end5 - begin5);
printf("MergeSort:%d\n", end6 - begin6);

free(a1);
free(a2);
free(a3);
free(a4);
free(a5);
free(a6);

}
int main()
{
testOP();
}
  • 结果显示：
    在这里插入图片描述
    这里我们给出100000个随机数字进行排序，通过运行的毫秒数来显示排序算法的效率高低，可以明显的看出直接插入排序的普通版本和选择排序的效率和性能是比较低的，而快排和归并排序的效率和性能是比较高的。堆排序和希尔排序效率也是比较高的。我们根据运行时间长短来衡量效率的高低。

总结

本文详细介绍了四大排序–插入排序（直接插入排序，希尔排序）、选择排序（直接选择排序，堆排序）、交换排序（冒泡排序，快速排序）的实现过程，以及它们的性能比较。代码都是我亲自打出来的，都已检验没问题，大家可以放心使用，如有错误，请批评指正，请大家多多支持。

南宫云落 kk
关注
  • 39
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
8种排序算法-测评对比（c语言程序）
06-11
按严蔚敏《数据结构》教材中的数据结构，实现了多种排序算法的程序设计，并进行实际数据输入测试对比。
c语言几种排序方法的比较,基于C语言的几种排序方法比较.doc
weixin_33435461的博客
05-22 221
基于C语言的几种排序方法比较.doc基于C语言的几种排序方法比较 【摘要】文章对c语言中的冒泡排序法、选择排序法、插入排序法进行比较讨论，以试图找出最佳排序方法。 【关键词】c语言;排序方法;比较 引言 排序是计算机程序设计中的一种重要操作，其作用是将一个数据元素(或记录)的任意序列重新排列成一个(按关键字)有序的序列[1]。按照排序记录数量分为内部排序及外部排序两类。若整个排序过程不需要访问外存...
【C语言】一篇文章搞定主流排序—— 插入排序、选择排序、交换排序、归并排序
qq_20963687的博客
09-24 588
算法
五大排序算法：插入、交换、选择、归并排序以及堆排序
张小艾博客
03-30 4219
四大排序算法的介绍以及代码实现
数据结构之排序（插入排序、交换排序、选择排序、归并排序）
qq_43752469的博客
10-03 2004
一、插入排序 1、直接插入排序 （1）插入步骤： （2）算法： （3）案例： （4）复杂度： 空间复杂度：O(1) 时间复杂度：O(n^2) （5）适用性：直接插入排序适用于顺序存储和链式存储的线性表。 2、折半插入排序 （1）思想：先用折半查找找出元素的待插入位置，再统一的移动待插入位置之后的所有元素。 （2）算法： （3）复杂度： 空间复杂度：O(1) 时间复杂度：O(n^2) 3、希尔排序 （1）基本思想：希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法
排序算法-基于C语言实现的排序算法之BubbleSort实现.zip
03-27
在计算机科学中，排序算法是数据结构...在实际项目中，我们可能会根据具体需求选择更高效的排序算法，如快速排序、归并排序、堆排序等。然而，了解和掌握冒泡排序对于理解排序算法的基本逻辑和优化思路具有重要意义。
排序算法-基于C语言实现的排序算法之BogoSort实现.zip
03-27
**排序算法** 排序算法是计算机科学中的重要概念，它用于将一组数据按照特定的顺序排列。...通过对比BogoSort和其他如快速排序、归并排序等高效的排序算法，我们可以更深入地掌握算法设计和分析的关键点。
排序算法-基于C语言实现的排序算法之SelectionSort实现.zip
最新发布
03-27
C语言是一种广泛应用的编程语言，其简洁的语法和高效的性能使其成为实现排序算法的理想选择。 **C语言** C语言是一种中级编程语言，由Dennis Ritchie在1972年开发。它提供了丰富的控制结构和低级内存操作，适合...
排序算法-基于C语言实现的排序算法之HeapSort实现.zip
03-27
它的语法简洁明了，适合编写底层算法，因此在实现排序算法时，C语言是一个理想的选择。C语言的内存管理和指针操作使得程序员可以直接操控数据，提高算法执行效率。 **HeapSort（堆排序）** HeapSort是由计算机科学...
排序算法-基于C语言实现的排序算法之CombSort实现.zip
03-27
虽然在实际应用中可能不如快速排序、归并排序等高级算法常见，但在理解和掌握更多排序算法原理方面，CombSort具有一定的学习价值。通过C语言实现CombSort，不仅可以锻炼编程技能，还能深入理解排序算法的工作机制。
十大排序①：插入、选择和交换排序
qq_39377889的博客
05-31 833
插入排序（直接插入、折半插入和希尔排序）选择排序（直接选择和堆排序）交换排序（冒泡和快速排序）的逻辑及代码
数据结构----排序（插入、交换、选择、归并）
qq_38198286的博客
07-11 730
目录一、排序概述二、插入排序1，直接插入排序2，折半插入排序3，希尔排序三、交换排序1，冒泡排序2，快速排序四、选择排序1，简单选择排序2，堆排序五、归并排序六、基数排序总结 一、排序概述 200 二、插入排序 1，直接插入排序 2，折半插入排序 3，希尔排序 三、交换排序 1，冒泡排序 2，快速排序 四、选择排序 1，简单选择排序 2，堆排序 五、归并排序 六、基数排序 总结 ...
[源码和文档分享]基于C语言的八大排序算法的比较
12-08 219
一、项目内容 将冒泡排序，选择排序，直接插入排序，希尔排序，快速排序，堆排序，归并排序，基数排序等八种排序方法做横向比较，针对相同的随机数据，比较排序算法所消耗的时间以及交换次数。 二、算法描述 2.1 冒泡排序 算法描述： 比较相邻的元素。如果第一个比第二个大，就交换他们两个 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这...
浅谈六种基本排序方法 ——插入排序，选择排序，交换排序，希尔排序，堆排序及快排
xxy_hl的博客
09-23 4588
以下排序均为升序，且所有操作均在数组中进行 直接插入排序 插入排序的基本思想是：每步将一个待排序的记录，按值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。 例如： 此图来源于百度百科 void insertSort(int *arr, int count) { //int *arr:传入一个整形数组； int count ： 数字总个数。 int first; //待排序...
插入排序、选择排序、交换排序和归并排序
zhangyi_ZY的博客
07-11 1768
常见的比较算法有： 排序算法的稳定性： 假定在待排序的序列中，存在多个相同的关键字，若经过排序，这些关键字的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。 一、插入排序 1.直接插入排序 思想：直接插入排序是在已有有序序列的基础上，在最末尾插入一个数，依次起从最大的数开始比较，如果大
五类排序算法(插入,交换,选择,归并)
biezhihua的专栏
08-17 8021
五种排序方法 插入排序 直接插入排序 希尔排序 交换排序 冒泡排序 快速排序 选择排序 简单选择排序 堆排序 归并排序 分类排序 排序方法基本思想和算法描述 直接插入排序/冒泡排序/简单选择排序,这些简单算法所需时间复杂度大为O(n^2). 希尔排序/快速排序/堆排序/归并排序,这些较复杂算法的时间复杂度,平均情况下位O(nlog2n),有些最快情况下退化成O(n^2).
链表的插入排序、交换排序、选择排序（多图详解）
makerjack001的博客
11-05 1220
能点进来这文章的肯定对链表有所认知，我就不科普了，这是我的链表类代码，用于接下来的介绍 struct Node { int data; Node* next; };//创建结构体——结点 class LinkList { private: Node* first; public: LinkList(); LinkList(int a[], int n); ~LinkList() {}; void insert(Node* a, Node* b);//把结点b插入结点a之后 void swa
C语言排序算法总结比较
qq_39446965的博客
03-05 500
C语言排序算法 1.选择排序法 void sort(int *nums,int numsSize){ for(int i=0;i<numsSize-1;i++){ int min=nums[i],min_index=i; for(int j=i+1;j<numsSize;j++){ if(min>nums[j]){ min=nums[j]; min_index=j;
几种常见的排序算法
u010778652的专栏
02-24 886
一、分类与性能 1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。反之，就是非稳定的。 比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4,a
C语言学习：内排序方法详解-插入、交换、选择与归并排序
"C语言学习初期的排序技术讲解，包括插入排序、交换排序、选择排序和归并排序等内排序方法的介绍，强调了各种排序算法的基本思想、执行过程和时间复杂度分析，以及快速排序、堆排序和归并排序等高级排序算法的设计与...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值