内部排序算法总结

最新推荐文章于 2023-02-08 04:19:34 发布
最新推荐文章于 2023-02-08 04:19:34 发布
阅读量385 收藏
点赞数
分类专栏： C语言基础 数据结构与算法分析 读书笔记 文章标签： 数据结构-排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuyuanjia02008/article/details/50866583
版权

内部排序算法

生活中人们常用的排序方法经过抽象整理，形成计算机中如下几个方面的排序算法

  • 每当有新数据到来时插入到当前一个较小的有序表中，这个是插入排序
  • 给一个无序的表，然后交换次序使之有序，这个是快速排序
  • 每次选择当前n-i+1个记录中最小的一个，形成一个新的局部不断扩充的有序表，使之有序，这个是选择排序
  • 合并几个有序的记录为一个，使之为整体有序，这个叫做归并排序
  • 排序的时候需要考虑多个关键字（姓名，年龄，职业），按照多个关键字依次排序并形成最后的结果，这个叫做基数排序

自定义的数据结构

  • 如下所示
#define MAXSIZE 20
#define SIZE 100

typedef int KeyType;
typedef int KeysType;
typedef int InfoType;

typedef struct{
    KeyType key;
    InfoType otherinfo;
}RedType;

typedef struct{
 RedType r[MAXSIZE+1];
 int length;
}SqList;

#define HeapType SqList

typedef struct
{
    RedType rc;
    int next;
}SLNode;

typedef struct
{
    SLNode r[SIZE];
    int length;
}SLinkListType;

//radix definition
#define MAX_NUM_OF_KEY 2
#define RADIX 10
#define MAX_SPACE 100

typedef struct
{
    KeysType keys[MAX_NUM_OF_KEY];
    InfoType otheritems;
    int next;
}SLCell;

typedef struct
{
    SLCell r[MAX_SPACE];
    int keynum;
    int recnum;
}SLList;
typedef int ArrType[RADIX];

插入排序

  • 直接插入排序：最简单，始终保持有序的子表，然后加1通过比较移动保持有序，是稳定的，平方级的复杂度：
    ### 直接插入排序源码
//o(n*n)插入排序
void insertSort(SqList* L)
{
    int i = 2,j;
    for(i = 2;i<=L->length;++i)
    {
        if(LT(L->r[i].key,L->r[i-1].key))
        {
            L->r[0] = L->r[i];
            L->r[i] = L->r[i-1];
            for(j = i-2;LT(L->r[0].key,L->r[j].key);--j)
            {
                L->r[j+1]=L->r[j];
            }
            L->r[j+1] = L->r[0];
        }
    }
}
  • 折半插入排序：采用折半查找的策略减少了比较次数，但是移动次数依旧一样，是稳定的，平方级的复杂度：
 //binary search sort o(n*n)
void binaryInsertSort(SqList *L)
{
    int i,j;
    for(i = 2;i<=L->length;i++)
    {
        int low =1;
        int high = i-1;
        L->r[0] = L->r[i];
        while(low<=high)
        {
            int m = (low+high)/2;
            if(LT(L->r[0].key,L->r[m].key))
                high = m-1;
            else
                low=m+1;
        }
        for(j=i-1;j>=high+1;--j)
        {
            L->r[j+1] =L->r[j];
        }
        L->r[high+1] =L->r[0];
    }
}
  • 2路插入排序：用两个表代替一个表，中位数大的放在一个表，比他小的放在另外一个表，减少了移动次数，是稳定的，也是平方级的复杂度
void twoWayInsertSort(SqList *L,SLinkListType *S)
{
    int i =0;
    for(i = 2;i<=L->length;i++)
    {
        S->r[i].rc = L->r[i];
        S->r[i].next = 99;
        //S->r[S->r[0].next)].rc.key
        //printf("11:%d ",S->r[i].rc.key);
        if(LT(S->r[i].rc.key,S->r[S->r[0].next].rc.key))
        {
            //printf("22:%d ",S->r[i].rc.key);
            int lessMin = S->r[0].next;
            S->r[0].next = i;
            S->r[i].next = lessMin;
        }

        else
        {
            if(LT(S->r[i].rc.key,S->r[1].rc.key))
            {
                //printf("33:%d ",S->r[i].rc.key);
                insertStaticList(S,i,S->r[0].next);
            }
            else{
                //printf("44:%d ",S->r[i].rc.key);
                insertStaticList(S,i,1);
            }
        }
        //printf("%d ",S->r[i].rc.key);
    }
}
  • 表插入排序：通过修改指针的方式来代替数据记录的交换，稳定，平方级复杂度：
void arrangeSList(SLinkListType *S)
{
    int p = S->r[0].next,q;
    int i = 1;
    for(i=1;i<S->length;++i)
    {
        while(p<i)
            p=S->r[p].next;
        q=S->r[p].next;
        if(p!=i)
        {
            SLNode temp = S->r[p];
            S->r[p] = S->r[i];
            S->r[i] = temp;
            S->r[i].next = p;
        }
        p = q;
    }
}
  • 希尔排序：按照一定的增量序列（例如5,3,1的间隔，1是最大公因数，增量序列是2的n次方-1）划分各个子序列使其基本有序，然后每次进行直接插入排序，不稳定，1.5次方的复杂度，最多可以降到n*(log2n)2：
void shellInsert(SqList *S,int dk)
{
    int i,j;
    for(i=dk+1;i<=S->length;++i)
    {
        if(LT(S->r[i].key,S->r[i-dk].key))
        {
            S->r[0] = S->r[i];
            for(j=i-dk;j>=0&& LT(S->r[0].key,S->r[j].key);j-=dk)
            {
                S->r[j+dk] = S->r[j];
            }
            S->r[j+dk] = S->r[0];
        }
    }
}
void shellSort(SqList *S,int dlta[],int t)
{
    int k=0;
    for(k=0;k<t;k++)
        shellInsert(S,dlta[k]);
}

快速排序

  • 起泡排序： 起泡排序：将每个记录依次与其他所有记录相比较，使其交换顺序，不稳定，平方级复杂度。
  • 快速排序：用low和high两个指针依次分别和枢轴比较，先high往后走，比轴小交换位置，然后是low比轴大交换位置，一直到中间，不稳定的，性能比较好，是最好的内部排序（同数量级的平均性能最好，有序时候会退化为气泡排序），降低到n*logn的复杂度：
int partition(SqList *L,int low,int high)
{
    L->r[0] = L->r[low];
    int pivotKey = L->r[low].key;
    while(low < high)
    {
        while(low < high && L->r[high].key >= pivotKey)
            --high;
        L->r[low] = L->r[high];
        while(low < high && L->r[low].key <=pivotKey)
            ++low;
        L->r[high] = L->r[low];
    }
    L->r[low] = L->r[0];
    return low;
}
void quickSort(SqList *L,int low,int high)
{
    if(low < high)
    {
        int pivotloc =partition(L,low,high);
        quickSort(L,low,pivotloc-1);
        quickSort(L,low+1,high);
    }
}

选择排序

  • 简单选择排序：每次取出来当前最小的，放在前面，然后依次选择所有的元素，最后元素排序完毕，不稳定的，平方级复杂度：
int seleMinKey(SqList *L,int start)
{
    int i;
    int min=200;
    int j;
    for(i=start;i<=L->length;i++)
        if(L->r[i].key <min){
            min =L->r[i].key;
            j=i;
        }
    return j;
}
void selectSort(SqList *L)
{
    int i = 1;
    for(i =1;i<L->length;i++)
    {
        int j = seleMinKey(L,i);
        printf("%d\n",j);
        if(i !=j)
        {
            RedType temp = L->r[i];
            L->r[i] = L->r[j];
            L->r[j] = temp;
        }
    }
}
  • 堆排序（针对的是完全二叉树）：非终端（叶子）节点的值不大于其左右孩子节点的值，分为调整和构建两周策略，每次输出根节点：
    1.每次调整从n/2到0，判断孩子节点是否需要调整交换，一直到根节点结束；
    2.堆顶记录，依次与n到2的节点交换位置，然后调整，形成最终的大顶堆（小顶堆）。
    性能最差不会超过n*logn.
    void heapAdjust(HeapType *H,int s,int m)
{
    int j;
    RedType rc=H->r[s];
    for(j=2*s;j<=m;j*=2)
    {
        if(j<m && LT(H->r[j].key,H->r[j+1].key))
            ++j;
        if(!LT(rc.key,H->r[j].key))
            break;
        H->r[s] = H->r[j];
        s=j;
    }
    H->r[s] =rc;
}
void heapSort(HeapType *H)
{
    int i;
    for(i=H->length/2;i>=0;--i)
    {
        heapAdjust(H,i,H->length);
    }
    for(i=H->length;i>1;--i)
    {
       RedType temp = H->r[1] ;
       H->r[1] = H->r[i];
       H->r[i] = temp;
       heapAdjust(H,1,i-1);
    }
}

归并排序

  • 归并排序：时间也是比较快（n*logn），且是稳定的，可能主要用于外部排序，思路是：采用归并两个有序表的策略（例如两路），通常采用递归形式实现（不断取中间位置，然后在栈中弹出，不断归并）
void merge(RedType SR[],RedType *TR,int i,int m,int n)
{
    int j,k;
    for(j=m+1,k=i;i<=m&&j<=n;++k)
    {
        if(LT(SR[i].key,SR[j].key))
            TR[k]=SR[i++];
        else
            TR[k]=SR[j++];
    }
    while(i<=m)
        TR[k++] = SR[i++];
    while(j<=n)
        TR[k++] = SR[j++];
}
void mSort(RedType SR[],RedType *TR1,int s,int t)
{
    int m;
    if(s==t)
        TR1[s]=SR[s];
    else{
        SqList *TR2 = (SqList *)malloc(sizeof(SqList));
        m=(s+t)/2;
        mSort(SR,(TR2->r),s,m);
        mSort(SR,(TR2->r),m+1,t);
        merge(TR2->r,TR1,s,m,t);
    }
}

基数排序

  • 基数排序：（d*(n+rd),在n远大于d的时候可以采用，可以稳定也可以不稳定，MSD，LSD的区别）
    链式基数排序：从低到高位，每次拉成桶内的局部队列，然后按照桶的关键字大小依次排成一个整体的链表，然后重复，直到排序完所有的基数。

    借助于比较的排序算法的最好时间复杂度：nlogn.

void initSLList(SLList *L)
{
    int i;
    L->keynum = MAX_NUM_OF_KEY;
    L->recnum = MAXSIZE+1;
    srand((unsigned) time(NULL));

    L->r[0].keys[0] = 9;
    L->r[0].keys[1] = 9;
    L->r[0].next = 1;
    for(i=1;i<MAXSIZE+1;i++)
    {
        L->r[i].keys[0] = rand()% 10;
        L->r[i].keys[1] = rand()% 10;
        L->r[i].next = i+1;
    }
    L->r[L->recnum-1].next = 0;
}

void traverseSLList(SLList *L)
{
    int p,i=0;
    for(p = L->r[0].next;p;p=L->r[p].next)
    {
        i++;
        printf("|| %d %d ",p,L->r[p].keys[0]+L->r[p].keys[1]*10);
    }
    printf("\n");
   /* for(p=0;p<MAXSIZE+1;p++)
    {
        printf("||%d %d %d ",p,L->r[p].next,L->r[p].keys[0]+L->r[p].keys[1]*10);
    }
    printf("\n");*/
}

int succ(int j)
{
    return j+1;
}

int ord(int i)
{
    return i;
}

void distribute(SLCell *r,int i,int *f,int *e)
{
    int j,p;
    for(j=0;j<RADIX;++j)
    {
        f[j] = 0;
        e[j] = 0;
    }
    for(p=r[0].next;p;p=r[p].next)
    {
        j=ord(r[p].keys[i]);
        if(!f[j])
            f[j] = p;
        else
            r[e[j]].next = p;
        e[j] = p;
    }
}

void collect(SLCell *r,int i,int *f,int *e)
{
    int j,t;
    for(j=0;!f[j];j=succ(j));
    r[0].next=f[j];
    t=e[j];
    while(j<RADIX)
    {
        for(j=succ(j);j<(RADIX-1) &&!f[j] ;j=succ(j));
        if(f[j])
        {
            r[t].next = f[j];
            t=e[j];
        }
    }
    r[t].next = 0;
}

void traverseFE(SLList *L,int f[],int e[])
{
    int j;
    for(j=0;j<RADIX;j++)
    {
        int temp = f[j];
        printf("%d : %dF->",j,f[j]);
        printf("%d ",L->r[temp].keys[0]+L->r[temp].keys[1]*10);
        while(temp !=e[j])
        {
            temp = L->r[temp].next;
            printf("%d ",L->r[temp].keys[0]+L->r[temp].keys[1]*10);
        }
        printf("<-%dE",e[j]);
        printf("\n");
    }
}

void radixSort(SLList *L)
{
    int i=0,j=0;
    int f[RADIX];
    int e[RADIX];
    /*for(i=0;i<L->recnum;++i)
        L->r[i].next = i+1;
    L->r[L->recnum-1].next = 0;*/
    for(i=0;i<L->keynum;++i)
    {
        distribute(L->r,i,f,e);
        traverseFE(L,f,e);
        collect(L->r,i,f,e);
    }
    traverseSLList(L);
}
MurphyXu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
nlogn级别的排序算法（1）归并排序
佳佳的博客
10-19 1819
nlogn级别的排序算法（1）归并排序nlogn到底比n^2快了多少？如下图，当待排序的数组长度达到1000时，nlogn的效率是n^2的1000倍……而这，可能是一天和三年的区别。归并排序基本思路 一个归并过程为：将数据一分为二，将两部分数据分排序，然后将这两个有序数组归并为一个数组； 实际过程中，数据可以不断的往下细分，直到只剩下一个数组元素为止。因此，算法应该采用递归的思想，即长度为1的数组排
关于复杂度的思考
zhangjiaji111的博客
11-02 3379
给出题目，先看问题规模，进而来判断时间复杂度，来推断算法知识点 - 常见的时间复杂度： 二分查找：logn 排序函数：nlogn 如果个人经验不够，那就选择不超过10^8。题目通常是1s。 时钟周期：2.5Ghz = 2500000000hz=2.5*10^9hz N=10000000——O(n)，只准遍历一遍，不准排序。 N=100000——O(nlogn)，可能有排序，或者二分。 N=20——O(2^N)，指数时间，二进制枚举。 N=1000, O(N^3), 1s，只有或运算。——值得尝试。 N=10
排序算法总结
l1394049664的博客
08-06 1627
目录 一、冒泡（n*n） 二、选择（n*n） 三、插入（n*n） 四、希尔排序（n*n） 五、快速排序( O(N*logN)) 六、堆排序 O(N*logN) 七、归并排序 O(N*logN) 八、基数排序(正数) 九、桶排序 十，计数排序 总结： 冒泡：在没有改进算法的情况下都是N*N，使用一个标志，一次遍历没有交换就结束（当数组是正序N） 插入：最好N（就是已经安装要...
时间复杂度分析
qq_51339192的博客
09-05 1205
时间复杂度分析 1.纯循环 有几层就是n多少方，一般循环 2.递归 快排和归并排序 每层都是O(n),有logn层，所以是nlogn规模的复杂度 二分 logn，因为每次都是对半分，2的x次方等于n，所以x就是logn 函数的渐近增长，我们在比如n方+n+1时，可以省略掉n+1，所以为n方的时间复杂度 用常数1来取代程序中的所有加法函数，比如说x++，那么我们在运算的时候就可以把它当作1的累加，即把x当作1 ...
第二章 2.3节
听枫烨阁的博客
11-13 1587
2.3-1 使用图2-4作为模型，说明归并排序再数组A=
排序算法总结.docx
03-23
外部排序通常涉及多个阶段的内部排序和数据的磁盘读写，如多路归并排序，将数据分块加载到内存中进行排序，然后将排序后的块合并。 在面试中，了解这些排序算法的原理、优缺点以及适用场景是至关重要的。对于项目中...
内部排序算法比较
03-22
**内部排序算法比较** 在计算机科学中，内部排序是指数据在内存中进行的排序过程，无需额外的存储设备。本报告主要关注了六种常见的内部排序算法：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序和堆...
几种内部排序算法总结
10-16
几种内部排序算法总结!(冒泡排序、快速排序、直接插入排序、拆半插入排序、简单选择排序)
算法运行时间1、logN、N、NlogN 、N^2、N^3、2^n之间的比较
南方以北
09-03 2万+
排序算法中，常常要求我们估算出最坏情况运行时间和平均情况/期望运行时间。在估算运行时间时，我们常用到下面一些时间量：  1  大部分程序的大部分指令之执行一次，或者最多几次。如果一个程序的所有指令都具有这样的性质，我们说这个程序的执行时间是常数。  logN   如果一个程序的运行时间是对数级的，则随着N的增大程序会渐渐慢下来，如果一个程序将一个大的问题分解成一系列更小的问题，每...
O(1), O(n), O(logn), O(nlogn) 的区别
热门推荐
null
09-28 11万+
在描述算法复杂度时，经常用到O(1), O(n), O(logn), O(nlogn)来表示对应复杂度程度, 不过目前大家默认也通过这几个方式表示空间复杂度 。 那么，O(1), O(n), O(logn), O(nlogn)就可以看作既可表示算法复杂度，也可以表示空间复杂度。 大O加上（）的形式，里面其实包裹的是一个函数f(),O（f()）,指明某个算法的耗时/耗空间与数据增长量之间的关系。其中...
算法运行时间、logN、NlogN 之间的比较
weixin_30580341的博客
01-27 831
1 大部分程序的大部分指令之执行一次，或者最多几次。如果一个程序的所有指令都具有这样的性质，我们说这个程序的执行时间是常数。 logN 如果一个程序的运行时间是对数级的，则随着N的增大程序会渐渐慢下来，如果一个程序将一个大的问题分解成一系列更小的问题，每一步都将问题的规 模缩减成几分之一，一般就会出现这样的运行时间函数。在我们所关心的范围内，可以认为运行时间小于...
【算法导论系列】开篇，与时间复杂度
dingzr2001的博客
06-06 2959
时间复杂度以及O, Θ, Ω三个符号的详细说明及应用
各种排序算法时间复杂度和稳定性总结【转】
lanximu的专栏
09-23 1460
转载自：http://blog.csdn.net/lockedstar/article/details/5699388 原文:blog.chinaunix.net/u/1222/showart_318070.html 排序算法是一种基本并且常用的算法。由于实际工作中处理的数量巨大，所以排序算法对算法本身的速度要求很高。而一般我们所谓的算法的性能主要是指算法的复杂度，一般用O方法来表示。在后
时间复杂度
最新发布
2303_76433058的博客
02-08 1024
没啥东西
算法复杂度O(nlogn)详解
shikelang_pp的博客
08-13 2万+
首先看以下程序段： for（int i=1;i {           for(int j=1;j            {                    .....   //复杂度为O(1);             } } 求该程序段的时间复杂度。 可以看出：（1）当i=1时，需要执行n次；                      （2）当i=2时，需要执行n/2
浅谈算法和数据结构: 三 合并排序
weixin_34281537的博客
01-27 413
合并排序，顾名思义，就是通过将两个有序的序列合并为一个大的有序的序列的方式来实现排序。合并排序是一种典型的分治算法：首先将序列分为两部分，然后对每一部分进行循环递归的排序，然后逐个将结果进行合并。   合并排序最大的优点是它的时间复杂度为O(nlgn)，这个是我们之前的选择排序和插入排序所达不到的。他还是一种稳定性排序，也就是相等的元素在序列中的相对位置在排序前后不会发生变化。他的唯一缺点是，...
内部排序探析：表插入排序算法性能
总结来说，表插入排序是一种简单但效率受输入数据影响较大的内部排序算法，适合小规模或部分有序的数据。理解排序的基本概念和不同类型的排序方法对于优化算法性能和解决实际问题至关重要。在设计和选择排序算法时，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值