排序算法（冒泡、选择、直插、希尔、堆、归并、快排）

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量245 收藏 2
点赞数 1
分类专栏： 算法训练 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52103105/article/details/119210054
版权

文章目录

简单排序

#include <stdio.h>
#include <stdlib.h>
#define MAXN 10

void swap(int a[],int i,int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

int main()
{
    int num[MAXN] = {9,1,5,8,3,7,4,6,2,10};

    for(int i = 0; i < MAXN; ++i)
    {
        for(int j = MAXN-1; j > i; --j)
         if(num[j] < num[i])
            swap(num,i,j);
    }

    for(int i = 0; i < MAXN; ++i)
        printf("%d ",num[i]);

    return 0;
}

冒泡排序

普通冒泡排序
能够有效的减少swap函数的调用次数，提高速度。

#include <stdio.h>
#include <stdlib.h>
#define MAXN 10

void swap(int a[],int i,int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

int main()
{
    int num[MAXN] = {9,1,5,8,3,7,4,6,2,10};

    for(int i = 0; i < MAXN-1; ++i)  //前面排序好了最后一个位置不用排序
    {
        for(int j = MAXN - 2; j >= i; --j) //从尾向头开始才能保证位置i为最小的数
            if(num[j] > num[j+1])
            swap(num,j+1,j);
    }

    for(int i = 0; i < MAXN; ++i)
        printf("%d ",num[i]);

    return 0;
}

优化冒泡排序
当没有发生位置互换时其实已经代表后面的数也是排序好的了，所以不用再循坏了

#include <stdio.h>
#include <stdlib.h>
#define MAXN 10

void swap(int a[],int i,int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

int main()
{
    int num[MAXN] = {9,1,5,8,3,7,4,6,2,10};
    int flag = 1;
    for(int i = 0; i < MAXN-1 && flag; ++i)
    {
        flag = 0;
        for(int j = MAXN-2; j >= i ; --j)
        {
            if(num[j] > num[j+1])
            {
                swap(num,j,j+1);
                flag = 1;
            }
        }
    }
    for(int i = 0; i < MAXN; ++i)
        printf("%d ",num[i]);

    return 0;
}

时间复杂度
最优:第一次i循坏就排序完成——O(n)
最差:需要比较 i-1 （i:2~10）的总和，为（n-1）*（n-1）/2——O（n^2）

选择排序

#include <stdio.h>
#include <stdlib.h>
#define M 10

void swap(int a[],int i,int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

int main()
{
    int num[M] = {9,1,5,8,3,7,4,6,2,10};
    int min;
    for(int i = 0; i < M-1; ++i)
    {
        min = i;
        for(int j = i+1; j < M; ++j)
            if(num[j] < num[min])
            min = j;
        if(min != i)
            swap(num,i,min);
    }
     for(int i = 0; i < M; ++i)
        printf("%d ",num[i]);

    return 0;
}

时间复杂度
需要比较 i-1 （i:2~10）的总和，为（n-1）*（n-1）/2
最优情况下交换0次，最差情况下交换n-1次
时间复杂度:O(n^2)
因为最坏只要交换n-1次所以选择排序普遍优于冒泡

直接插入排序

#include <stdio.h>
#include <stdlib.h>
#define M 10

void swap(int a[],int i,int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

int main()
{
    int num[M] = {9,1,5,8,3,7,4,6,10,2};
    int k,j;

    for(int i = 1; i < M; ++i)
    {
        k = num[i];
        j = i;
        while(j > 0 && num[j-1] > k)
        {
            num[j] = num[j-1];
            j--;
        }
        num[j] = k;
    }
     for(int i = 0; i < M; ++i)
        printf("%d ",num[i]);

    return 0;

}

算法复杂度
最优（本身有序）:比较n-1次
最差：外层循坏n-1次，内层比较 i 次——O(n^2)

希尔排序

希尔排序通过一个增量将原来的数组变成一个较为有序的序列，然后再执行一次增量为1的排序（等同于最普通的插入排序）。
每次内层循坏可以看做一个根据增量的分组，再对这个分组进行插入排序。
关于增量的选择：只要最后增量能够达到1即可
（代码也表现插入排序j的两种不同写法，但原理都是相同）

#include <stdio.h>
#include <stdlib.h>
#define M 10

void swap(int a[],int i,int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

int main()
{
    int num[M] = {9,1,5,8,3,7,4,6,2,10};
    int increment = M;
    int j,k;
    do
    {
        increment = increment/3+1;
        for(int i = increment; i < M; ++i)
        {
            if(num[i] < num[i-increment])
            {
                k = num[i];
                for(j = i-increment; j >= 0 &&  num[j] > k; j -= increment)   //根据增量分组出一个序列并对这个序列进行插入排序
                    num[j+increment] = num[j];
                num[j+increment] = k;
            }
        }
    }while(increment > 1);
    for(int i = 0; i < M; ++i)
        printf("%d ",num[i]);

    return 0;

}

时间复杂度
O（nlogn）

堆排序

为什么用完全二叉树？因为这样第一次排序时，子结点只有一层，不用考虑忽略了最大结点在另一边的情况，底部排序好顶部的多层排序就足以完成。
这部代码充分体现了这一点。

void HeadSort(int num[],int m)
{
    for(int i = m/2-1; i >= 0; --i)
        HeapAdjust(num,i,m); //先维护底部

    for(int i = 0; i < m-1; ++i)
    {
        swap(num,0,m-1-i);
        HeapAdjust(num,0,m-i-1); 正如我所说的底部的有序使顶部的排序成为可能
    }
}

为什么是选择排序的改进？因为它维护堆的方式，犹如选择排序，找出最大（或小）的子节点，保存下来最后互换两个结点。

#include <stdio.h>
#include <stdlib.h>
#define M 10

void swap(int a[],int i,int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

void HeapAdjust(int num[],int s,int m) //将s-m维护成大顶堆
{
    int t = num[s];
    int j;

    for(j = s*2+1; j < m; j = j*2+1)
    {
        if(j < m-1 && num[j] < num[j+1])  //防止越界与找出左右孩子中的最大值
            j++;
        if(t >= num[j])
            break;
        num[s] = num[j];
        s = j;  //代表着s与j的互换在下个循坏中起效
    }

    num[s] = t;
}

void HeadSort(int num[],int m)
{
    for(int i = m/2-1; i >= 0; --i)
        HeapAdjust(num,i,m);

    for(int i = 0; i < m-1; ++i)
    {
        swap(num,0,m-1-i);
        HeapAdjust(num,0,m-i-1); 正如我所说的底部的有序使顶部的排序成为可能
    }
}

int main()
{
    int num[M] = {9,1,5,8,3,7,4,6,2,10};
    HeadSort(num,M);
     for(int i = 0; i < M; ++i)
        printf("%d ",num[i]);

    return 0;
}

时间复杂度
构建堆：至多进行两次比较(由于底层已经构建完成,完全二叉树第一次构建底部只有一层子节点比较一次)，时间复杂度O(n)
重建堆：对于第i次重建堆需要循坏log（M-i-1），且共进行M-1次——O（nlogn）
总体：O（nlogn）

归并排序

注意MSort会用到边界所以t一定要代入最后一个元素位置而不是数组大小（本代码中t要代入9不能是10）
递归实现

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10
void MergeSort(int a[],int n)
{
    MSort(a,a,0,n-1);
}

void MSort(int SR[],int TR1[],int s,int t)
{
    int TR2[MAXSIZE];
    int m;
    if(s == t)
        TR1[s] = SR[s];
    else
    {
        m = (s+t)/2;
        MSort(SR,TR2,s,m);
        MSort(SR,TR2,m+1,t);
        Merge(TR2,TR1,s,m,t);
    }
}

void Merge(int SR[],int TR[],int i,int m,int n)
{
    int j,k,l;

    for(k = i,j = m+1; i <= m && j <= n; ++k)
    {
        if(SR[i] > SR[j])
            TR[k] = SR[j++];
        else
            TR[k] = SR[i++];
    }

    if(i <= m)
    {
        for(l = 0; l <= m-i; ++l)
            TR[k+l] = SR[i+l];
    }
    else if(j <= n)
    {
        for(l = 0; l <= n-j; ++l)
            TR[k+l] = SR[j+l];
    }
}

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

非递归实现

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10

void Merge(int SR[],int TR[],int i,int m,int t) //t为最尾元素下标
{
    int j,k,l;

    for(k = i,j = m+1; i <= m && j <= t; ++k)
    {
        if(SR[i] > SR[j])
            TR[k] = SR[j++];
        else
            TR[k] = SR[i++];
    }
    if(i <= m)
    {
        for(l = 0; l <= m-i; ++l)
            TR[k+l] = SR[i+l];
    }
    else if(j <= t)
    {
        for(l = 0; l <= t-j; ++j)
            TR[k+l] = SR[j+l];
    }
}

void MergePass(int SR[],int TR[],int s,int n) //注意n为最尾元素下标
{
    int i = 0;

    while(i <= n-2*s+1)  //能否完成下次归并的最小元素个数
    {
        Merge(SR,TR,i,i+s-1,i+2*s-1);
        i = i+2*s;
    }

    //将剩余的序列归并
    if(i < n-s+1)  //若有超过s长度的序列则可以归并
        Merge(SR,TR,i,i+s-1,n);
    else
    {
        for(int j = i; j <= n; ++j)
            TR[j] = SR[j];
    }
}

void MergeSort(int TR[],int n)  //n为数组长度
{
    int *SR = (int *)malloc(sizeof(int)*n);
    int k = 1;

    while(k < n)
    {
        MergePass(TR,SR,k,n-1);
        k *= 2;
        MergePass(SR,TR,k,n-1);
        k *= 2;
    }
}

int main()
{
    int num[MAXSIZE] = {9,1,5,8,3,7,4,6,2,10};
    MergeSort(num,MAXSIZE);
    for(int i = 0; i < 10; ++i)
        printf("%d ",num[i]);
    return 0;
}

时间复杂度
O(nlogn)

快速排序

#include <stdio.h>
#include <stdlib.h>

void q_sort(int num[],int begin,int end)
{
    if(begin >= end)
        return;

    int t = num[begin];
    int i =  begin, j = end-1;

    while(i < j)
    {
        while(i < j && num[j] >= t)
            j--;
        if(i < j)
        {
            num[i] = num[j];
            i++;
        }
        while(i < j && num[i] <= t)
            i++;
        if(i<j)
        {
            num[j] = num[i];
            j--;
        }
    }
    num[i] = t;
    q_sort(num,begin,i-1);
    q_sort(num,i+1,end);
}

int main()
{
    int num[10] = {9,1,5,8,3,7,4,6,2,10};
    q_sort(num,0,10);
    for(int i = 0; i < 10; ++i)
        printf("%d ",num[i]);
    return 0;
}

快排优化

#include <stdio.h>
#include <stdlib.h>
#define MAX_LENGTH_INSERT_SORT 7

void InsertSort(int num[],int n)
{
    int t;
    int j;
    for(int i = 1; i < n; ++i)
    {
        t = num[i];
        j = i;
        while(j > 0 && num[j-1] > t)
            {
                num[j] = num[j-1];
                j--;
            }
        num[j] = t;

       /*
       for(j = i-1; j >= 0 && num[j] > t; --j)
         num[j+1] = num[j];
       num[j+1] = t;
       */
    }
}

int Partitionl(int a[],int low,int high)
{
    int i = low, j = high;
    int t = a[i];

    while(i < j)
    {
        while(i < j && a[j] >= t)
            j--;
        if(i < j)
        {
            a[i] = a[j];
            i++;
        }
        while(i < j && a[i] <= t)
            i++;
        if(i < j)
        {
            a[j] = a[i];
            j--;
        }
    }
    a[i] = t;

    return i;
}

void QSort(int a[],int low,int high,int n)
{
    int p;
    if((high-low) > MAX_LENGTH_INSERT_SORT)
    {
        while(low < high)
        {
            p = Partitionl(a,low,high);
            QSort(a,low,p-1,n);
            low = p+1;
        }
    }
    else
        InsertSort(a,n);
}


int main()
{
   int num[10] = {9,1,5,8,3,7,4,6,2,10};
    QSort(num,0,9,10);
    for(int i = 0; i < 10; ++i)
        printf("%d ",num[i]);
    return 0;
}

时间复杂度
O(logn)

czyaaa.
关注
专栏目录
五种排序算法（插入排序、冒泡排序、快速排序、二分归并排序、堆排序）
xzf_cellery的博客
01-31 275
#include <iostream> #include<stdio.h> #define N 100 using namespace std; //输入函数及输入 //10 //7 30 5 6 9 4 21 6 5 8 in_put(int a[],int n) { // cout<<"sorti:"; for(int i=0;i<n;i++) { cin>>a[i]; // cout<&l
七大排序算法（插排，希尔，选择排序，堆排，冒泡，快排，归并）--图文详解
qq_52592775的博客
09-04 9045
万字长文加N多图片喂你七大排序的知识点, 让你用脚都能写出排序算法
四种排序：冒泡排序、快速排序、归并排序和堆排序
weixin_48018951的博客
02-08 690
四种排序对比总结带代码，冒泡排序、快速排序、归并排序、堆排序
几种常见排序算法的代码实现（插入排序、冒泡排序、归并排序、快速排序）
星海浮生
08-02 312
本文介绍几种常见排序算法（插入排序、冒泡排序、归并排序、快速排序）的 Python 代码实现，不对算法原理做深入解释。
四种排序算法（冒泡排序、选择排序、归并排序、快速排序）的实现
Leon的博客
11-13 465
本文用C++实现了四种基础的排序算法，冒泡排序、选择排序、归并排序、快速排序 #include <bits/stdc++.h> using namespace std; void Swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; return; } void BubbleSort(int num[], int len, bool flag) { int temp=0
几个常用排序：快速排序、归并排序、冒泡排序自己手敲代码（JAVA）并注释
fxhbeyond的专栏
07-07 196
1、快速排序： 利用递归，每次把数组按标记位分为两部分，左边部分所有值小于标记位的值，右边部分所有值大于标记位的值 /** * Created by fanxh on 2020/6/30. * 快速排序 * 利用递归，每次把数组按标记位分为两部分，左边部分所有值小于标记位的值，右边部分所有值大于 * 标记位的值 */ public class QuickSort { public static int[] qsort(int arr[],int start,int end) {
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
HanMeng的博客
07-24 60万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
十大排序算法（冒泡排序、插入排序、选择排序、希尔排序、堆排序、快排、归并排序、桶排序、计数排序、基数排序）
2301_80215560的博客
03-10 1万+
十大排序算法（冒泡排序、插入排序、选择排序、希尔排序、堆排序、快排、归并排序、桶排序、计数排序、基数排序）十大排序的思想和代码的实现！！！
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
基于比较的排序算法汇总 选择排序法 插入排序法 归并排序法 快速排序法 堆排序法 冒泡排序法 希尔排序法
01-15
本文将深入探讨标题中提到的几种基于比较的排序算法：选择排序、插入排序、归并排序、快速排序、堆排序、冒泡排序以及希尔排序。 1. **选择排序（Selection Sort）**： - 基本思想：在未排序的序列中找到最小（或...
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字...
7大排序算法实现程序（快速排序，冒泡排序，选择排序，归并排序，插入排序，希尔排序，堆排序）
06-21
本资源提供了七大经典排序算法的实现程序，包括快速排序、冒泡排序、选择排序、归并排序、插入排序、希尔排序和堆排序。下面将逐一详细介绍这些排序算法及其原理。 1. 快速排序：由C.A.R. Hoare提出，是一种采用...
七种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速）
zhupengqq的博客
02-03 195
七种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速） 首先声明一下，本文只对七种排序算法做简单总结，并参照一些资料给出自己的代码实现，并没有对某种算法理论讲解，更详细的 了 解可以参考以下资料（本人参考）： 1、《 data structure and algorithm analysis in c 》 2、《大话数据结构》 3、 http://blog.csdn.net/...
34. 在排序数组中查找元素的第一个和最后一个位置
weixin_61695887的博客
10-12 493
请你找出给定目标值在数组中的开始位置和结束位置。给你一个按照非递减顺序排列的整数数组。你必须设计并实现时间复杂度为。如果数组中不存在目标值。
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 802
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 148
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 357
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
【优选算法】（第四十二篇）
weixin_73861555的博客
10-15 778
输⼊：beginWord="hit",endWord="cog",wordList=["hot","dot","dog","lot","log","cog"]输出：5。输⼊：beginWord="hit",endWord="cog",wordList=["hot","dot","dog","lot","log"]输出：0。解释：⼀个最短转换序列是"hit"->"hot"->"dot"->"dog"->"cog",返回它的⻓度5。解释：endWord"cog"不在字典中，所以⽆法进⾏转换。
【鸟类识别系统】Python+卷积神经网络算法+人工智能+深度学习+ResNet50算法+计算机课设项目
子午的博客
10-12 868
鸟类识别系统。本系统采用Python作为主要开发语言，通过使用加利福利亚大学开源的200种鸟类图像作为数据集。使用TensorFlow搭建ResNet50卷积神经网络算法模型，然后进行模型的迭代训练，得到一个识别精度较高的模型，然后在保存为本地的H5格式文件。在使用Django开发Web网页端操作界面，实现用户上传一张鸟类图像，识别其名称。本项目通过人工智能技术实现对鸟类图像的自动识别，满足用户在日常生活中快速、准确地识别鸟类的需求。
C语言实现各种排序算法：冒泡、插入、选择、快速、堆、归并及希尔排序
"本资源提供了C语言实现的多种排序算法，包括冒泡排序、希尔排序、插入排序、选择排序、快速排序、堆排序和归并排序。这些排序算法的时间复杂度从O(n^2)到O(n log n)不等，适用于不同的数据规模和场景。其中，插入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值