排序

最新推荐文章于 2024-03-28 00:29:10 发布

风筝_

最新推荐文章于 2024-03-28 00:29:10 发布

阅读量711

点赞数

分类专栏：数据结构（C语言）文章标签：排序

本文链接：https://blog.csdn.net/m0_38062470/article/details/111408078

版权

数据结构（C语言）专栏收录该内容

10 篇文章 0 订阅

订阅专栏

参考：十大经典排序算法

一.基本概念

1.什么是关键字？什么是主关键字？什么是次关键字？

2.什么是稳定的排序方法？什么是不稳定的排序方法？

3.什么是内部排序？什么是外部排序？

4.内部排序方法有哪些？

5.评价排序算法优劣的标准主要有什么？

6.插入排序的基本思想是什么？（内部排序第一类）

11.交换排序的主要思想是什么？（内部排序第二类）

12.什么是冒泡排序？

一.基本概念

1.什么是关键字？什么是主关键字？什么是次关键字？

答：

关键字是数据元素中某个数据项的值，用它可以标识一个数据元素。

通常会用记录来表示数据元素，一个记录可以由若干个数据项组成。

例如，一个学生的信息就是一条记录，它包括学号、姓名、性别等若干数据项。

主关键字是可以唯一地标识一个记录的关键字，如学号。

次关键字是可以标识若干记录的关键字，如姓名、性别等。

2.什么是稳定的排序方法？什么是不稳定的排序方法？

答：若在待排序的记录中，存在两个或两个以上关键字相等的记录，排序之后这些记录的相对次序仍然保持不变，则称相应的排序方法是稳定的排序方法，否则是不稳定的排序方法。

3.什么是内部排序？什么是外部排序？

答：根据排序过程中涉及的存储器不同，可以将排序方法分为两大类：一类是内部排序，指的是待排序的记录存放在计算机随机存储器中进行的排序过程；另一类是外部排序，指的是在排序过程中要对外存储器进行访问的排序过程。

4.内部排序方法有哪些？

根据排序过程中所依据的原则可以将它们分为5类：插入排序、交换排序、选择排序、归并排序和基数排序。

5.评价排序算法优劣的标准主要有什么？

算法的运算量，主要通过记录的比较次数和移动次数来反映。（即时间复杂度）
执行算法所需要的附加存储单元的多少。（即空间复杂度）

6.插入排序的基本思想是什么？（内部排序第一类）

插入排序的基本思想是：每步都将一个待排序的记录，按其关键字值的大小插入到前面已经排序的文件中适当的位置上，直到全部插入完为止。

主要包括下面的直接插入排序和希尔排序。

7.什么是直接插入排序？

直接插入排序是一种简单的插入排序法，其基本思想是：将待排序的记录按照其关键字的大小逐个插入到一个已经排序好的有序序列中去，直到所有的记录插入完为止，得到一个新的有序序列。

算法思路：

1.设置监视哨r[0]，将待插入记录的值赋值给r[0]

2.设置开始查找的位置j

3.在数组中进行搜索，搜索中将第j个记录后移，直至r[0].key>=r[j].key为止

4.将r[0]插入到r[j+1]的位置上

//直接插入排序算法
void zjinsert(redtype r[],int n)   //n为数组r的长度
{
    int i,j;
    for(i=2;i<n;i++)              //i表示插入元素下标，此时1...i-1有序。i=0为监视哨，i=1时，只有一个元素，不用排序，所以i从2开始
    {
        j=i-1;                    //j表示比较元素下标
        r[0]=r[i];                //设置监视哨，将其设置为待插入的结点
        while(r[0].key<r[j].key)  //寻找插入点，并进行元素的移动
        {
            r[j+1]=r[j];          //前一结点向后移动          
            j--;
        }
        r[j+1]=r[0];              //插入待排序的结点，即监视哨的值
    }
}

直接插入排序分析：

插入n个记录所需的平均移动次数近似为(n^2)/4。因此，直接插入排序的时间复杂度为O(n^2)；

整个排序过程中只需要一个记录单元的辅助空间，所以其空间复杂度为O(1)

直接插入排序是一种稳定的排序方法

8.直接插入排序适合什么情况呢？

答：当数据规模比较小或者数据基本有序时十分高效。

但是基本有序或规模较小都不常见，怎样改进一下插入排序，使得它对较大规模并且无序的数据也非常有效呢？

这就引出了下面的希尔排序。

9.什么是希尔排序？

希尔排序又称“缩小增量排序”，也是一种插入排序类的算法，与直接插入排序相比，在时间效率上有较大的改进。

希尔排序的思路是：

选定第一个增量d1<n，把全部记录按此值从第一个记录起进行分组，所有相距为d1的记录作为一组。

先在各组内进行插入排序，然后缩小间隔，取第二个增量d2<d1，重复上述分组和排序过程，如此反复，直至增量d1=1为止，即所有的记录放在同一组内排序。

算法思路：

外循环以各种不同的间隔距离d进行排序，直到d=1为止

第二重循环是在某一个d值下对各组进行排序，若在某个d值下发生了记录的交换，则需要继续第三重循环，直至各组内均无记录的交换为止，即各组内已完成排序任务。

第三重循环是从第一个记录开始，以某个d值为间距进行组内比较。若有逆序，则进行交换。

void slpx(redtype r[],int n)  //n为数组r的长度
{
    int j;
    int k;
    redtype t;
    int d=n/2;                          //置初始增量为元素个数的一半
    while(d>=1)                         //依次取出各增量
    {
        for(k=d;k<n;k++)                //对每一元素实施插入排序，将其分别插入各自的分组中
        {
            t=r[k];                     //保存待插入记录
            j=k-d;                      //待插入记录所属分组的前一记录
            while(j>=0&&t.key<r[j].key) //比较两个记录的大小
            {
                r[j+d]=r[j];            //插入排序，较大的前一记录向后移动
                j-=d;                   //寻找本分组的前一记录
            }
            r[j+d]=t;                   //插入一个记录
        }
        d/=2;                           //增量减半
    }
}

10.希尔排序有什么特点呢？

希尔排序的主要特点是每一趟以不同的增量进行插入排序。当d较大时，被移动的记录是跳跃式进行的。到最后一趟排序时，许多记录已经有序，不需要多少移动，所以提高了排序的速度。一般来说，希尔排序比直接插入排序要快，平均比较次数和记录平均移动次数均为n^1.3左右。

希尔排序是不稳定的排序方法。

11.交换排序的主要思想是什么？（内部排序第二类）

交换排序通过两两比较待排序记录的关键值，交换不满足顺序的那些偶对，直到全部满足为止。

主要包括：冒泡排序和快速排序

12.什么是冒泡排序？

冒泡排序也叫气泡排序、起泡排序等。冒泡排序通过相邻记录的两两比较和交换，使关键字较小的记录像水中的气泡一样逐趟向上漂浮；而关键字大的记录好比石块往下沉，每一趟有一块最大的石头沉到水底。

基本思路：

先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序（即r[1].key>r[2].key），则交换两个记录；然后比较第二个记录和第三个记录的关键字，若为逆序，则又交换两个记录；如此下去，直到第n-1个记录的关键字和第n个记录的关键字比较完为止，这样就完成了第一趟冒泡排序，其结果是关键字最大的记录被安置到第n个记录的位置。

接着进行第二趟冒泡排序，对前n-1个记录进行类似操作，其结果是关键字次大的记录被安置到第n-1个记录的位置。

对含有n个记录的文件最多需要进行n-1趟冒泡排序。

算法思路：

第一重循环进行n-1趟排序，设标志k初值为0；

第二重循环是在进行第i趟排序时进行n-i次两两比较，若逆序，则交换并使k值增加，找出该趟的最大值放到第n-i+1位置上，继续进行下一趟排序，在一趟排序的过程中，若序列有序，无交换记录，标志k为0，则退出整个排序循环

void mppx(redtype r[],int n)
{
    int i,j,k;
    redtype x;
    i=1;
    k=1;
    while((i<n)&&(k>0))    //进行n-1趟排序
    {
        k=0;
        for(j=1;j<=n-i;j++)  //在进行第i趟排序时进行n-i次两两比较
        {
            if(r[j+1].key<r[j].key)   //交换记录
            {
                k++;                   //改变交换标志k
                x=r[j];
                r[j]=r[j+1];
                r[j+1]=x;
            }
        }
    }
}

13.冒泡排序有什么特点呢？

当初始序列中记录已经按关键字次序排好序，则只需要进行一趟排序，在排序的过程中只需要进行n-1次比较，记录移动次数为0；反之，若初始序列按逆序排列，则最多进行n-1趟排序

总的时间复杂度为O(n^2)

冒泡排序是稳定的，因为关键字相等的记录不会相互交换。

14.什么是快速排序？

快速排序是对冒泡排序的一种改进。冒泡排序中记录的比较和交换是在相邻的单元中进行，记录每次交换只能上移或下移一个单元，因而总的比较和移动次数较多。

快速排序中，记录的比较和交换是从两端向中间进行，关键字较小和较大的记录一次就能换到前面或后面，记录每次移动的距离较远，所以可以减少比较和移动的次数

基本思路：

在待排序的n个记录中任选一个记录，通常选择第一个记录，以该记录的关键字值为基准，用交换的方法将所有记录分成两部分，使所有关键字比基准小的记录均排在基准记录之前，所有关键字比基准大的记录均排在基准记录之后，基准记录在两部分之间，其位置为该基准记录的最终位置，它不再参加以后的排序，这就完成了一趟排序。

接着对所划分的前后两部分分别重复上面的操作，直到每部分内容只有一个记录为止，排序结束。

/
//快速排序的区域划分方法
//在区间low和high之间进行一次划分
/
int partition(redtype r[],int low,int high)
{
    int i=low;
    int j=high;
    int t=r[i].key;   //t为划分的基准值
    //寻找基准点的位置
    do
    {
        while(t<=r[j].key&&i<j)  //基准点与右半区的元素逐个比较大小
        {
            j--;
        }
        if(i<j)                   //在右半区找到一个比基准小的元素
        {
            r[i]=r[j];            //将小的记录放到左半区
            i++;
        }
        while(r[i].key<=t&&i<j)   //在基准点的左半区搜索比它大的记录
        {
            i++;
        }
        if(i<j)                   //在左半区找到一个比基准大的记录
        {
            r[j]=r[i];             //将大的记录放到右半区
            j--;
        }
    }while(i<j);                  //如此重复，直到左右半区相接
    r[i].key=t;
    return i;
}


//快速排序算法
/
void quicksort(redtype r[],int low,int high)
{
    int position;
    if(low<high)                       //当区间下界小于区间上界
    {
        position=partition(r,low,high);  //将该区间分成两半，position为分界点
        quicksort(r,low,position-1);     //对左半区进行快速排序
        quicksort(r,position+1,high);    //对右半区快速排序
    }
}

15.快速排序有什么特点呢？

快速排序的平均时间复杂度为O(nlbn)。

快速排序是目前基于比较的内部排序方法中速度最快的，快速排序也因此得名。

快速排序需要一个栈空间来实现递归。

最好情况下，所需栈空间为O(lbn)，最坏情况下，递归深度为n，所需栈空间为O(n)

快速排序算法不稳定

16.选择排序的主要思想是什么？（内部排序第三类）

选择排序是指每次从待排序的记录中选出关键字值最小（或最大）的记录，顺序放在已排序的有序记录中，直到全部排完为止。

主要包括简单选择排序和堆排序。

17.什么是简单选择排序？

基本思路：

对待排序的文件进行n-1趟扫描，第i趟扫描选出剩下的n-i+1个记录中关键字值最小的记录和第i个记录互相交换。

第一次待排序的空间为r[1]-r[n]，经过选择和交换后，r[1]中存放最小的记录

第二次待排序的区间为r[2]-r[n]，经过选择和交换后，r[2]中存放次小的记录

以此类推，最后，形成r[1....n]成为有序序列

void zjxz(redtype r[],int n)
{
    int i,j,k;
    redtype x;
    for(i=1;i<n;i++)   //进行第i趟排序，共n-1趟
    {
        k=i;
        for(j=i+1;j<=n;j++)  //在待排序列中查找关键字最小的记录
        {
            if(r[j].key<r[k].key)
            {
                k=j;
            }
        }
        if(i!=k)      //将关键字值最小的记录r[k]和r[i]交换
        {
            x=r[i];
            r[i]=r[k];
            r[k]=x;
        }
    }
}