排序

最新推荐文章于 2024-03-28 00:29:10 发布
最新推荐文章于 2024-03-28 00:29:10 发布
阅读量101 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blll0/article/details/111903319
版权

排序

一、排序的基本概念与分类

  • 内排序：在排序的整个过程中，待排序的所有记录全部被放置在内存中
  • 外排序：由于排序的记录个数太多，不能同时放置在内存，整个排序过程需要在内外存之间多次交换数据才能进行

二、冒泡排序

冒泡排序：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止

对顺序表L作交换排序（冒泡排序初级版）

void BUbbleSort0(SqList *L)
{
    int i.j;
    for(i=1;i<L->length;i++)
    {
        for(j=i+1;j<=L->length;j++)
        {
            if(L->r[i]>L->r[j])
            {
                swap(L,i,j);//交换L->r[i]与L->r[j]的值
            }
        }
    }
}

对顺序表L作冒泡排序

void BubbleSort(SqList *L)
{
    int i.j;
    for(i=1;i<L->length;i++)
    {
        for(j=L->length-1;j>=i;j--)//j是从后往前循环
        {
            if(L->r[j]>L->r[j+1])
            {
                swap(L,j,j+1);//交换L->r[j]与L->r[j+1]的值
            }
        }
    }
}

对顺序表L作改进冒泡算法

void BubbleSort2(SqList *L)
{
    int i,j;
    Status flag=TRUE;//flag用来作为标记
    for(i=1;i<L->length&&flag;i++)//若flag为true则退出循环
    {
        flag=FALSE;//初始化为false
        for(j=L->length-1;j>=i;j--)//j是从后往前循环
        {
            if(L->r[j]>L->r[j+1])
            {
                swap(L,j,j+1);//交换L->r[j]与L->r[j+1]的值
                flag=TRUE;
            }
        }
    }
}

三、简单选择排序

简单选择排序法：通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i（1<=i<=n）个记录交换之。

对顺序表L作简单选择排序

void SelectSort(SqList *L)
{
    int i,j,min;
    for(i=1;j<L->length;i++)
    {
        min=i;//将当前下标定义为最小值下标
        for(j=i+1;j<=L->length;j++)//循环之后的数据
        {
            if(L->r[min]>L->r[j])//如果有小于当前最小值的关键字
            {
                min=j;//将此关键字的下标赋值给min
            }
        }
        if(i!=min)//若min不等于i，说明找到最小值，交换
        {
            swap(L,i,min);//交换L->r[i]与L->r[min]的值
        }
    }
}

四、直接插入排序

直接插入排序：将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表

对顺序表L作直接插入排序

void InsertSort(SqList *L)
{
    int i,j;
    for(i=2;i<=L->length;i++)
    {
        if(L->r[i]<L->r[i-1])//需将L->r[i]插入有序子表
        {
            L->r[0]=L->r[i];//设置哨兵
            for(j=i-1;L->r[j]>L->r[0];j--)
            {
                L->r[j+1]=L->r[j];//记录后移
               
            }
            L->r[j+1]=L->r[0];//插入到正确位置 
        }
    }
}

五、希尔排序

对顺序表L作希尔排序

void ShelSort(SqList *L)
{
    int i,j;
    int increment=L->length;
    do
    {
        increment=increment/3+1;//增量序列
        for(i=increment+1;i<=L->length;i++)
        {
            if(L->r[i]<L->r[i-increment])
            {
                //需将L->r[i]插入有序增量子表
                L->r[0]=L->r[i];//暂存在L->r[0]
                for(j=i-increment;j>0&&L->r[0]<L->r[i];j-=increment)
                {
                    L->r[j+increment]=L->r[j];//记录后移，查找插入位置
                }
                L->r[j+increment]=L->r[0];//插入
            }
        }
            
    }
    while(increment>1);
    
}

六、堆排序

堆是具有下列性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

堆排序基本思想：将待排序的序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次大值，反复执行，即可得到一个有序序列。

对顺序表L进行堆排序

void HeapSort(SqLIst *L)
{
    int i;
    for(i=L->length/2;i>0;i--)//把L中的r构建成一个大顶堆
    {
        HeapAdjust(L,i,L->length);
    }
    for(i=L->length;i>1;i--)
    {
        swap(L,1,i);//将堆顶记录和当前未经排序子序列的最后一个记录交换
        HeapAdjust(L,1,i-1);//将L->r[1..i-1]重新调整为大顶堆
    }
}

HeapAdjust(堆调整)函数的实现

//已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义
//本函数调整L->r[s]的关键字，使L->r[s..m]成为一个大顶堆
void HeapAdjust(SqList *L,int s,int m)
{
    int temp,j;
    temp=L->r[s];
    for(j=2*s;j<=m;j*=2)//沿关键字较大的孩子结点向下筛选
    {
        if(j<m&&L->r[j]<L->r[j+1])
        {
            ++j;//j为关键字中较大的记录的下标
        }
        if(temp>=L->r[j])
        {
            break;//rc应插入在位置s上
        }
        L->r[s]=L->r[j];
        s=j;
    }
    L->r[s]=temp;//插入
}

七、归并排序

归并排序的原理：假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]（[x]表示不小于x的最小整数）个长度为2或1的有序子序列；再两两归并…，如此重复，直至得到一个长度为n的有序序列为止，这种排序方法叫2路归并排序

对顺序表L作归并排序

void MergeSort(SqList *L)
{
    MSort(L->r;L->r,1,L->length);
}

MSort的实现

//将SR[s..t]归并排序为TR1[s..t]
void MSort(int SR[],int TR[],int s,int t)
{
    int m;
    int TR2[MAXSIZE+1];
    if(s==t)
    {
        TR1[s]=SR[s];
    }
    else
    {
        m=(s+t)/2;//将SR[s..t]平方为SR[s..m]和SR[m+1..t]
        MSort(SR,TR2,s,m);//递归将SR[s..m]归并为有序的TR2[s..m]
        MSort(SR,TR2,m+1,t);//递归将SR[m+1..t]归并为有TR2[m+1..t]
        Merge(TR2,TR1,s,m,t);//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
    }
}

Merge函数的实现

//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
void Merge(int SR[],int TR[],int i,int m,int n)
{
    int j,k,l;
    for(j=m+1,k=1;i<=m&&j<=n;k++)//将SR中记录由小到大归并入TR
    {
        if(SR[i]<SR[j])
        {
            TR[k]=SR[i++];
        }
        else
        {
            TR[k]=SR[j++];
        }
        
    }
    if(i<=m)
    {
        for(l=0;l<=m-i;l++)
        {
            TR[k+1]=SR[i+1];//将剩余的SR[i..m]复制到TR
        }
    }
    if(j<=n)
    {
        for(l=0;l<=n-j;l++)
        {
            TR[k+1]=SR[j+1];//将剩余的SR[j..n]复制到TR
        }
    }
}

对顺序表L作归并非递归排序

void MergeSort2(SqList *L)
{
    int *TR=(int*)malloc(L->length*sizeof(int));//申请额外空间
    int k=1;
    while(k<L->length)
    {
        MergePass(L->r,TR,k,L->length);
        k=2*k;//子序列长度加倍
        MergePass(TR,L->r,k,L->length);
        k=2*k;//子序列长度加倍
    }
}

MergePass代码实现

//将SR[]中相邻长度为s的子序列两两归并到TR[]
void MergePass(int SR[],int TR[],int s,int n)
{
    int i=1;
    int j;
    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)//归并最后两个序列
    {
        Merge(SR,TR,i,i+s-1,n);
    }
    else//若最后只剩下单个子序列
    {
        for(j=i;j<=b;j++)
        {
            TR[j]=SR[j];
        }
    }
}

八、快速排序

快速排序的基本思想：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的

对顺序表L作快速排序

void QuickSort(SqList *L)
{
    QSort(L,l,L->length);
}

Qsort的实现

//对顺序表中的子序列L->r[low..high]作快速排序
void QSort(SqList *L,int low,int high)
{
    int pivot;
    if(low<high)
    {
        pivot=Partition(L,low,high)//将L->r[low..high]一分为二算出枢轴值pivot
        QSort(L,low,pivot-1);//对低子表递归排序
        QSort(L,pivot+1,high);//对高子表递归排序
    }
}

Partition函数实现

//交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置
//此时在它之前（后）的记录均不大（小）于它
int Partition (SqList *L,int low,int high)
{
    int pivotkey;
    pivotkey=L->r[low];//用子表的第一个记录作枢轴记录
    while(low<high)//从表的两端交替向中间扫描
    {
        while(low<high&&L->r[high]>=pivotkey)
        {
            high--;
        }
        swap(L,low,high);//将比枢轴记录小的记录交换到低端
        while(low<high&&L->r[low]<=pivotkey)
        {
            low++;
        }
        swap(L,low,high);//将此枢轴记录大的记录交换到高端
    }
    return low;//返回枢轴所在位置
}

快速排序优化算法

int Partition (SqList *L,int low,int high)
{
    int pivotkey;
    int m=low+(high-low)/2;//计算数组中间的元素的下标
    if(L->r[low]>L->r[high])
    {
        swap(L,low,high);//交换左端和右端数据，保证左端较小
    }
    if(L->r[m]>L->r[high])
    {
        swap(L,high,m);//交换中间与右端数据，保证中间较小
    }
    if(L->r[m]>L->r[low])
    {
        swap(L,m,low);//交换中间与左端数据，保证左端较小
    }
    //此时L.r[low]已经为整个序列左中右三个关键字的中间值
    pivotkey=L->r[low];//用子表的第一个记录作枢轴记录
    L->r[0]=pivotkey;//将枢轴关键字备份到L->r[0]
    while(low<high)//从表的两端交替向中间扫描
    {
        while(low<high&&L->r[high]>=pivotkey)
        {
            high--;
        }
        L->r[high]=L->r[low];//采用替换而不是交换的方式进行操作
        L->r[low]=L->r[high];//采用替换而不是交换的方式进行操作
        swap(L,low,high);//将比枢轴记录小的记录交换到低端
        while(low<high&&L->r[low]<=pivotkey)
        {
            low++;
        }
        swap(L,low,high);//将此枢轴记录大的记录交换到高端
    }
    return low;//返回枢轴所在位置
}

改进QSort函数

#define MAX_LENGTH_INSERT_SORT 7//数组长度阈值
//对顺序表中的子序列L->r[low..high]作快速排序
void QSort(SqList *L,int low,int high)
{
    int pivot;
    if((high-low)>MAX_LENGTH_INSERT_SORT)
    {
        //当high-low大于常数时用快速排序
        pivot=Partition(L,low,high)//将L->r[low..high]一分为二算出枢轴值pivot
        QSort(L,low,pivot-1);//对低子表递归排序
        QSort(L,pivot+1,high);//对高子表递归排序
    }
    else//当high-low小于或等于常数时直接插入排序
    {
        InsertSort(L);
    }
}

对QSort实施尾递归优化

#define MAX_LENGTH_INSERT_SORT 7//数组长度阈值
//对顺序表中的子序列L->r[low..high]作快速排序
void QSort(SqList *L,int low,int high)
{
    int pivot;
    if((high-low)>MAX_LENGTH_INSERT_SORT)
    {
        while(low<high)
        {
        	//当high-low大于常数时用快速排序
        	pivot=Partition(L,low,high)//将L->r[low..high]一分为二算出枢轴值pivot
        	QSort(L,low,pivot-1);//对低子表递归排序
        	low=pivot+1;//尾递归
        }
    }
    else//当high-low小于或等于常数时直接插入排序
    {
        InsertSort(L);
    }
}
【大话数据结构C语言】69 归并排序（递归和迭代实现）
CodeAllen嵌入式
05-23 959
堆排序之所以效率比较高是利用了完全二叉树，但是堆排序的设计本身是比较复杂的 那就引出一个问题，有没有更简单的使用完全二叉树来排序的算法呢？ 这就引出了归并排序算法 归并排序 归并排序就是利用归并的思想实现的排序方法，原理是假设初始序列含有n个记录，则可以看出是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2或者1的有序子序列；再两两归并。。。。如此反复，直至得到一个长度为n的有序序列为止，这种排序方法称为2路规定排序 其排序的过程就是完全二叉树 ...
堆排序详细图解（通俗易懂）
oorik的博客
02-17 25万+
什么是堆 堆是一种叫做完全二叉树的数据结构，可以分为大根堆，小根堆，而堆排序就是基于这种结构而产生的一种程序算法。 堆的分类 大根堆:每个节点的值都大于或者等于他的左右孩子节点的值 小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值 两种结构映射到数组为: 大根堆: 小根堆: //父-->子:i--->左孩子:2*i+1, 右孩子:2*i+2; //子-->父:i--->(i-1)*2;(i为下标元素) 排序思想 1.首先将待排序的数...
【笔记】大话数据结构-排序
Ethan_997的博客
09-24 264
排序的稳定性 排序前相等的两个关键字的记录r1与r2，此时r1在r2前面，排序后若仍然是r1在r2前面，则为稳定的；否则不稳定。 内排序与外排序 内排序：排序过程中，待排序所有记录全部放在内存中。 外排序：记录过多，不能同时放在内存，整个排序过程需要内外存之间多次交换数据。 冒泡排序 最简单排序实现：两两比较相邻关键字，反序则交换，直到没有反序记录。两个循环嵌套即可，i从1开始，j从i+1开始。 冒泡排序算法：i从1开始，j从length-1开始，比较r[j]和r[j+1]的大小做交换。 void Bu
《大话数据结构》第9章 排序 9.8 归并排序（上）
weixin_33910137的博客
04-25 143
9.8.1 归并排序介绍         前面我们讲了堆排序，因为它用到了完全二叉树，充分利用了完全二叉树的深度是⌊log2n⌋+1的特性，所以效率比较高。不过堆结构的设计本身是比较复杂的，老实说，能想出这样的结构就挺不容易，有没有更直接简单的办法利用完全二叉树来排序呢？当然是有。         先来举一个例子。你们知道高考一本、二本、专科分数线是如何划分出来的吗？         简...
《大话数据结构》之归并排序
艺海拾贝
02-26 578
#include #include #include #define MAX_LEN 256 typedef struct { int iInput[MAX_LEN]; int iLength; }SqArr; int Output(SqArr *pSqToPrint) { int iLoop; for(iLoop=1;iLoopiLength;iLoop++) { pri
大话数据结构之归并排序
11-22 340
归并排序思想：假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两合并，得到[n/2]个长度为2或1 的有序子序列；再两两合并，。。。。。。如此重复，直到得到一个长度为n的有序序列为止，也称为2路归并排序。 归并排序的时间复杂度：O(nlogn)
快速排序法（详解）
热门推荐
小白的博客
07-01 58万+
假设对以下10个数进行快速排序： 6 1 2 7 9 3 4 5 10 8 我们先模拟快速排序的过程：首先，在这个序列中随便找一个数作为基准数，通常为了方便，以第一个数作为基准数。 6 1 2 7 9 3 4 5 10 8 在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位...
冒泡排序（超详细）
hcz666的博客
06-11 38万+
1、什么是冒泡排序？ 冒泡排序的英文Bubble Sort，是一种最基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。 冒泡排序的原理： 每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。 而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面
python数组排序方法详解（sort， sorted，argsort）
什么都干的派森
09-27 7万+
这三个排序方法应对日常工作基本够用 先说一下三者的区别 sort， sorted 是用在 list 数据类型中的排序方法 argsort 是用在 numpy 数据类型中的排序方法（ numpy 里也有一个 sort 方法，下面会讲） sort 和 sorted 的区别如下???? 先看两个简单的升序排序，分别使用 sorted 和 sort 方法 # sorted num_list = [1, 8, 2, 3, 10, 4, 5] ordered_list = sorted(num_list) print
插入排序、归并排序、堆排序和快速排序的稳定性分析
最新发布
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-28 2165
在计算机科学中，排序是将一组数据按照特定顺序进行排列的过程。排序算法的效率和稳定性是评价其优劣的两个重要指标。稳定性指的是在排序过程中，相等的元素在排序后保持原有的相对顺序。本文将详细分析插入排序、归并排序、堆排序和快速排序这四种常见排序算法的稳定性，并通过浅显易懂的语言进行解释。
有重复元素的排列问题设R={ r , r , , rn 1 2 可能相同。试设计}是要进行排列的n个元素。其中元素n r , r , , r 1 2
03-11
有重复元素的排列问题 Description 设R={ r , r , , rn 1 2 可能相同。试设计}是要进行排列的n个元素。其中元素n r , r , , r 1 2 一个算法，列出R的所有不同排列。 编程任务： 给定n 以及待排列的n 个元素。计算出这n 个元素的所有不同排列。 Input 输入数据的第1 行是元素个数n，1£n£500。接下来的1 行是待排列的n个元素。 Output 程序运行结束时，将计算出的n 个元素的所有不同排列输出，最后1 行中的数是排列总数。 Sample Input 4 aacc Sample Output aacc acac acca caac caca ccaa 6
大话数据结构-归并排序
年糕的博客
04-07 181
归并排序 时间复杂度：O(logn) 空间复杂度：O(n) 代码： #include <stdio.h> #include <string.h> #include <stdlib.h> #include <stdbool.h> #define swap(a,b) {typeof(a) temp=a; a=b; b=temp;} void show...
【大话数据结构&算法】归并排序
lmb55的专栏
08-08 1279
归并排序算法的基本步骤：1、把0~length-1的数组分成左数组和右数组； 2、对左数组和右数组进行迭代排序； 3、将左数组和右数组进行合并，那么生成的整个数组就是有序的数据数组。归并排序基本算法实现如下：void _merge_data_in_array(int[] array, int start,int middle,int end){ int[] mergeA
【大话数据结构&算法】快速排序算法
lmb55的专栏
08-03 2054
快速排序是交换类的排序，比如在站队的时候，老师说：“第一个同学出列，其他同学以第一个同学为中心，比他矮的全排在左边，比他高的全排在右边。”这就是一趟快速排序。可以看出，一趟快速排序是以一个“枢轴”为中心，将序列分成两个部分，枢轴的一边全是比它小（或者小于等于）的，另一边则全是比它大（或者大于等于）的。快速排序算法采用了一种分治的策略，通常称其为分治法，其基本思想是：1、先从数列中取出一个数作为基准数
《大话数据结构》之快速排序
艺海拾贝
02-27 791
#include #include #include #define MAX_LEN 256 typedef struct { int iInput[MAX_LEN]; int iLength; }SqArr; void swap(SqArr *pToSwap,int iFirst,int iSecond) { if (iFirst != iSecond) { pToSwap
大话数据结构之快速排序
11-21 455
快速排序的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到真个序列有序的目的。 快速排序的时间复杂度：O(nlogn)
大话数据结构系列之快速排序算法
威少（微笑）
02-02 3713
文章目录实现思路重点知识代码实现优化策略算法比较与各位共勉 实现思路 1、属于冒泡排序的升级版，都是通过不断的比较和移动交换来实现排序，它的实现，增大了记录的比较和移动的距离，将关键字较大的记录从前面直接移动到后面，关键字较小的记录从后面直接移动到前面，从而减少了总的比较次数和移动交换次数。 2、通过一趟排序将待记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这...
【大话数据结构C语言】70 快速排序
CodeAllen嵌入式
05-23 1287
目录 背景 快速排序 复杂度 快速排序的优化 背景 快速排序是图灵奖获得者 Tony Hoare设计提出的 快速排序被誉为20世纪十大算法之一 希尔排序是直接插入排序的升级，属于插入排序 堆排序是简单选择排序的升级，属于选择排序类 快速排序是冒泡排序的升级，属于交换排序类 快速排序是增加了记录的比较和移动的距离，将关键字较大的记录从前面直接移到后面，关键字较小的记录从后边直接移到前面，从而减少了比较次数和移动交换的次数 快速排序 快排的基本思想是，通过一趟排...
大话数据结构 －－ 排序
Maggie的博客
09-09 642
基本概念 排序： 假设含有n个记录的序列为{r1,r2,......,rn}，其相应的关键字分别为{k1,k2,......,kn}，需确定1,2,......,n的一种排列p1,p2,......,pn，使其相应的关键字满足kp1≤kp2≤......≤kpn（非递减或非递增）关系，即使得序列成为一个按关键字有序的序列{rp1,rp2,......,rpn}，这样的操作就称为排序。 在排序问...
C++排序算法大全
资源摘要信息:"超多c++排序.zip是一个包含丰富C++排序算法实现的压缩文件。排序算法是编程中经常使用到的基础数据处理方法，它可以帮助开发者有效地整理和管理数据。由于其在程序性能和效率方面的重要性，掌握排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值