十种排序算法

最新推荐文章于 2022-10-19 15:24:41 发布
最新推荐文章于 2022-10-19 15:24:41 发布
阅读量194 收藏 1
点赞数

1.常见算法分类
十种常见排序算法一般分为以下几种：
（1）非线性时间比较类排序：交换类排序（快速排序和冒泡排序）、插入类排序（简单插入排序和希尔排序）、选择类排序（简单选择排序和堆排序）、归并排序（二路归并排序和多路归并排序）；

（2）线性时间非比较类排序：计数排序、基数排序和桶排序。

总结：
（1）在比较类排序中，归并排序号称最快，其次是快速排序和堆排序，两者不相伯仲，但是有一点需要注意，数据初始排序状态对堆排序不会产生太大的影响，而快速排序却恰恰相反。

（2）线性时间非比较类排序一般要优于非线性时间比较类排序，但前者对待排序元素的要求较为严格，比如计数排序要求待排序数的最大值不能太大，桶排序要求元素按照hash分桶后桶内元素的数量要均匀。线性时间非比较类排序的典型特点是以空间换时间。
注：本博文的示例代码均已递增排序为目的。

2.1交换类排序
2.1.1冒泡类排序

void BubbleSort(int *arr,int size)
{
    int i,j;
    int flag,tmp;
    for(i = 0 ;i < size; i++)
    {
        flag = 1;
        for(j = 0 ; j < size - i - 1;j++)
        {
            if(arr[j] > arr[j + 1])
            {
                flag = 0;
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
        if(1 == flag)
        {
            break;
        }
    }
}

2.1.2快速排序

int Departition(int *arr,int left ,int right)
{
    int tmp = arr[left];
    while(left < right)
    {
        while(left < right && tmp < arr[right])
            right--;
        if(left < right)
            arr[left++] = arr[right];
        while(left < right && tmp > arr[left])
            left++;
        if(left < right)
            arr[right--] = arr[left];
    }
    arr[left] = tmp;
    return left;
}

void DoQuickSort(int *arr,int left,int right)
{
    int t;
    if(left < right)
    {
        t = Departition(arr,left,right);
        DoQuickSort(arr,0,t - 1);
        DoQuickSort(arr,t + 1,right);
    }
}
void QuickSort(int *arr,int size)
{
    DoQuickSort(arr,0,size -1);
}

2.2 插入类排序
2.2.1直接插入

void InsertSort(int *arr,int size)
{
    int i,j,tmp;
    for(i = 1 ; i < size; i++)
    {
        tmp = arr[i];
        j = i;
        while(j >= 1 && tmp < arr[j -1])
        {
            arr[j] =  arr[j -1];
            j--;
        }
        arr[j] = tmp;
    }
}

2.2.2 shell排序

void ShellSort(int *arr,int size,int d)
{
    int i,j,k,tmp;
    for(i = d;i > 0;i = i/2)
    {
        for(j = 0 ;j < size ; j += i)
        {
            tmp = arr[j];
            k = j;
            while(k >= i && tmp < arr[k - i])
            {
                arr[k] = arr[k - i];
                k -= i;
            }
            arr[k] = tmp;
        }
    }
}

2.3选择类排序
2.3.1直接选择类排序

  void SelectSort(int *arr,int size)
    {
        int i,j,min;
        int tmp;
        for(i = 0 ;i  < size; i++)
        {
            min = i;
            for(j = i + 1; j < size ; j++)
            {
                 if(arr[min] > arr[j])
                    min = j;
            }
            if(i != min)
            {
                tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }
        }
    }

2.3.2 堆排序

void AdjustHeap(int *arr,int node,int size)
{
    int child = 2*node + 1;
    int tmp = arr[node];
    while(child < size)
    {
        if(child + 1 < size && arr[child] < arr[child + 1])
        {
            child++;
        }
        if(tmp < arr[child])
        {
            arr[node] = arr[child];
            node = child;
            arr[node] = tmp;
            child = 2*child + 1;
        }
        else
        {
            break;
        }
    }
}
void HeapSort(int *arr,int size)
{
    int i,j,tmp;
    for(i = (size -1)/2 ; i >= 0 ; i--)
        AdjustHeap(arr,i,size);

    /*  printf("after create heap\n");
    for(i = 0 ; i < MAX ; i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    */
    for(i = 1 ;i < size; i++)
    {
        tmp = arr[0];
        arr[0] = arr[size - i];
        arr[size - i] = tmp;
        AdjustHeap(arr,0,size -i);
    }

}

2.4归并排序

void Merge(int *src,int *tmp,int begin,int mid,int end)
{
    int i = begin ,j = mid + 1,k = begin;
    while( i != mid + 1 && j != end + 1)
    {
        if(src[i] > src[j])
        {
            tmp[k++] = src[j++];
        }
        else
        {
            tmp[k++] = src[i++];
        }
    }
    while(i != mid + 1)
    {
        tmp[k++] = src[i++];
    }
    while(j != end + 1)
    {
         tmp[k++] = src[j++];
    }
    for(i = begin ; i <= end; i++)
    {
        src[i] = tmp[i];
    }
}

void MergeSort(int *src,int *tmp,int begin,int end)
{
    int mid;
    if(begin < end)
    {
        mid = (begin + end)/2;
        MergeSort(src,tmp,begin,mid);
        MergeSort(src,tmp,mid+1,end);
        Merge(src,tmp,begin,mid,end);
    }
}

以上是非线性时间比较类排序， 线性时间非比较类排序常见方法如下。
2.5计数排序

void CountSort(int *arr,int size)
{
    int i,j,count,max;
    int *tmp;
    max = arr[0];
    for(i = 1;i < size; i++)
    {
        if(max < arr[i])
        {
            max = arr[i];
        }
    }
    tmp = (int *)malloc(sizeof(int)*(max + 1));
    if(NULL == tmp)
    {
        printf("malloc failure\n");
        return;
    }
    memset(tmp,0,sizeof(int)*(max + 1));
    for(i = 0 ; i < size ; i++)
    {
        tmp[arr[i]]++;
    }

    count = 0;
    for(i = 0;i <= max; i++)
    {
       j = 0;
       while(j < tmp[i])
       {
           arr[count++] = i;
           j++;
       }
    }
    free(tmp);
    tmp = NULL;
}

2.6 基数排序

int GetDigitalPos(int num,int pos)
{
    int i,mask = 1;
    for(i = 0;i < pos -1; i++)
    {
        mask *= 10;
    }
    return (num/mask)%10;
}

void DistributionSort(int *arr,int size)
{
    int *buff[10] = {NULL}; /* 0 ~ 9 */
    int i,j;
    for(i = 0 ;i < 10; i++)
    {
        buff[i] = (int *)malloc(sizeof(int)*(size + 1));
        if(NULL == buff[i])
        {
            for(j = 0; j < i; j++)
            {
                free(buff[j]);
                buff[j] = NULL;
                return;
            }
        }
        buff[i][0] = 0; /* 保存统计数目 */
    }

    int index,count,k;
    for(i = 1; i < MAX_BIT; i++)
    {
        /* 装入桶中 */
        for(j = 0; j < size; j++)
        {
            index = GetDigitalPos(arr[j],i);
            buff[index][buff[index][0]+1] = arr[j];
            buff[index][0]++;
        }

        /* 将桶中数据装回原空间 */
        count = 0;
        for(j = 0; j < 10; j++)
        {
           for(k = 0; k < buff[j][0]; k++)
           {
               arr[count++] = buff[j][k + 1];
           }
           buff[j][0] = 0;
        }
    }

    /* 释放桶空间 */
     for(i = 0 ;i < 10; i++)
     {
         free(buff[i]);
         buff[i] = NULL;
     }
}

2.7 桶排序

struct bucket
{
    int num;
    int val;
    struct bucket *next;
};
void Release(struct bucket **root,int num)
{
    int i;
    struct bucket *node,*next;
    struct bucket **tmp = root;

    if(NULL == tmp)
    {
        return;
    }

    for(i = 0; i < num; i++)
    {
        if(tmp[i])
        {
            node = tmp[i];
            while(node)
            {
                next = node ->next;
                free(node);
                node = next;
            }
            tmp[i] = NULL;
        }
    }

    if(tmp)
    {
        free(tmp);
        tmp = NULL;
    }
}
void BucketSort(int *arr,int size)
{
    int i,index;
    struct bucket *p,*node;
    struct bucket **root = (struct bucket **)malloc(sizeof( struct bucket *)*BUCKET_NUM);
    if(NULL == root)
    {
        printf("malloc failure \n");
        return;
    }

    for(i = 0; i < BUCKET_NUM; i++)/* BUCKET_NUM 桶数目 */
    {
        root[i] = (struct bucket *)malloc(sizeof(struct bucket));
        if(NULL == root[i])
        {
           Release(root,BUCKET_NUM);
           return;
        }
        root[i] ->num = 0;
        root[i] ->next = NULL;
        root[i] ->val = 0;
    }

    /* 将数据装入桶中 */
    for(i = 0; i < size; i++)
    {
        index = arr[i]/BUCKET_NUM;
        p = root[index];
        node = (struct bucket *)malloc(sizeof(struct bucket));
        if(NULL == node)
        {
            Release(root,BUCKET_NUM);
            return;
        }
        node ->val = arr[i];
        node ->next = NULL;
        if(p ->num == 0)
        {
            p ->next = node;
        }
        else
        {
            while(p ->next && p ->next ->val <= arr[i])
                p = p ->next;
            node ->next = p ->next;
            p ->next = node;
        }
        (p ->num)++;
    }

    /* 打印 */
    for(i = 0; i < BUCKET_NUM; i++)
    {
        p = root[i] ->next;
        while(p != NULL)
        {
            printf("%d ",p ->val);
            p = p ->next;
        }
    }
    printf("\n");
    Release(root,BUCKET_NUM);
}

转：https://blog.youkuaiyun.com/coolwriter/article/details/78732728

Excel 2010 VBA 入门 043 按自定义序列进行排序
复行数十步
04-14 2756
示例： 如图所示，该表为某医院医务人员一览表。现在希望能够将该表数据以C列（科室）按照“外妇科l手术室l内儿科l西医科l中医科l耳鼻喉科I放射科l检验科l超室|口腔科l针灸科I西药房l中药房l收费室J疾控科l合管办|后勤科”的依次顺序进行排序，如何利用VBA实 现？ 序号 姓名 科室 级别 身份 职称 受聘专业 参工时间 工作年限 入院时间 入院年限 职务 1 张1张 后勤科 中级 干部 主治医师..
vb.net 遍历目录 按日期排序_VBA编程常用的排序算法（一）计数排序
weixin_39867125的博客
12-05 977
七月的风，八月的雨，卑微的我喜欢遥远的你……1，半夜好哦，大家。长期关注我们EH公众号的朋友都知道，老祝家有个丫头在统计局上班，她曾经眼睛都不眨的对我说过这样一句话：排序是数据分析与处理过程中最常见也是最重要的问题之一，搞定排序可以提升工作效率3.485626%……看在老祝爱发红包的份上，我当然对她这话发自肺腑的相信，所以曾发过两篇推文：如何使用VBA代码对表格中的数据排序处理？【Exc...
VBA排序的十种算法
08-08
vba 排序排序 算法，和好用的。可以直接用的。
VBA排序算法
chenpy303的博客
07-22 2730
主要算法有： 1、（冒泡排序）Bubble sort 2、（选择排序）Selection sort 3、（插入排序）Insertion sort 4、（快速排序）Quick sort 5、（合并排序）Merge sort 6、（堆排序）Heap sort 7、（组合排序）Comb Sort 8、（希尔排序）Shell Sort 9、（基数排序）Radix Sort 10、S
十种常见的排序算法
shi201619616的博客
10-03 521
来自Damonore的博客 原文：https://mp.weixin.qq.com/s/putWU_FBF7cZJkuVpCy0sw  
VBA七种排序算法
Eternal_Whispers的博客
10-19 2532
VBA排序算法
三十种排序算法的可视化
04-09
标题中的“三十种排序算法的可视化”指的是一个项目或软件，它通过图形化的方式展示了三十种不同的排序算法的运行过程。排序算法是计算机科学中基础且重要的部分，用于组织和整理数据，使得数据按照特定顺序排列。这...
十种排序算法可视化比较深入学习
文件名称“十种排序算法的可视化比较”暗示了将会有多种排序算法在同一平台或环境下进行比较。可视化比较不仅可以帮助学习者直观地看到不同算法在执行相同任务时的表现，包括时间复杂度和空间复杂度，还可以加深对...
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
从零开始学算法：十种排序算法介绍
09-06
“从零开始学算法：十种排序算法介绍” 本文主要介绍了十种排序算法，包括选择排序、插入排序、冒泡排序等，并对每种算法的时间复杂度进行了分析。作者首先介绍了选择排序的算法思路，即每次从数列中找出一个最小的...
7种排序算法的效率比较
12-07
算法课的一个小项目，语言python。代码实习7种排序算法，TK实现简单GUI，源码可以学习7中排序算法详细实现，和GUI的搭建，基本包含了常用GUI组件。
PHP 实现冒泡排序算法 （php7.1数组赋值）
dmedaa的博客
11-07 503
冒泡排序 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 算法原理 比较相邻的元素。如果第一个比第二个大，就交换他们
JavaScript十种排序算法总结
weixin_42572968的博客
03-25 600
十种排序对比 排序的分类 1 冒泡排序（BubbleSort） 特点：稳定排序（stable sort）、原地排序（In-place sort） 思想：通过两两交换，像水中的泡泡一样，小的先冒出来，大的后冒出来。 最坏运行时间：O(n^2) 最佳运行时间：O(n^2)（当然，也可以进行改进使得最佳运行时间为O(n)） 冒泡排序算法的运作如下：（从后往前） （1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。 （2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应
经典算法学习 - 收集
"代码"的日常搬运
12-05 3875
1.介绍 算法是一种思想，其实也没有我们想的那么高深，有时候就是生活中一些例子，只不过被一些人整得很深奥 【个人感受，虽然我们不能学习到所有的算法，但是了解一些，于工作，于生活，都是意想不到的好处】 2.学习/操作 如果想学习一门知识，技能，自然是从简单的，常见，常用的血气，了解它，会使用它，即便刚开始不了解原理，只是后来保不齐可以领悟工作原理/ ...
算法4 vba实现快速排序
perfect_red的博客
12-10 1818
快速排序快速实现三向切分 快速实现 Sub debugTest() Dim a() As Variant a = Array(6, 2, 5, 3, 7, 4, 6) sort a Debug.Print 1 End Sub Sub sort(a() As Variant) doSort a, LBound(a), UBound(a) End Sub Sub doSort(a() As Variant, low As Long, hi
springboot尿毒症健康管理系统的设计与实现论文
最新发布
08-12
springboot尿毒症健康管理系统的设计与实现
python 列表文本转表格
08-12
python
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值