精华内容
下载资源
问答
  • 假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是...

    什么是排序算法稳定性?

    假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳定的。

    076ee4ea66cfff6d832290499b881a14.png

    常见排序算法介绍

    插入排序

    通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

    具体实现算法(python)如下图:

    0c7d1f566752f53c1d59f5ff693f012f.png

    时间复杂度:平均 O(n^2) 最优 O(n) 最差 O(n^2)

    空间复杂度:O(1)

    是否稳定性算法:是

    选择排序

    在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

    具体实现算法(python)如下图:

    8cd5ee50add441828bd52204516283d8.png

    时间复杂度:平均 O(n^2) 最优 O(n^2) 最差 O(n^2)

    空间复杂度:O(1)

    是否稳定排序算法:是(在判断用>=时,非稳定)

    冒泡排序

    重复走访要排序的序列,两两比较顺序错误就交换,依此类推,直到走完要排序序列,这时最大(最小)数浮动到数列末尾。

    具体算法实现(python)如下图:

    d6abef98a9b7f4bd2576df0dcf80cc85.png

    时间复杂度:平均 O(n^2) 最优 O(n^2) 最差 O(n^2)

    空间复杂度:O(1)

    是否稳定排序算法:是

    快速排序

    又称划分交换排序。快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为较小和较大的2个子序列,然后递归地排序两个子序列。

    步骤为:

    挑选基准值:从数列中挑出一个元素,称为“基准”(pivot)。

    分割:重新排序数列,所有比基准值小的元素摆放在基准前面,所有比基准值大的元素摆在基准后面(与基准值相等的数可以到任何一边)。在这个分割结束之后,对基准值的排序就已经完成。

    递归排序子序列:递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。

    具体算法实现(python)如下图:

    9d66989a3d8ef527931ca8bfc8e149af.png

    5d0d2dba4c2a3952cf0c0d17e0e80e30.png

    时间复杂度:平均 O(nlogn) 最优 O(nlogn) 最差O(n^2)

    空间复杂度:O(logn) - 递归堆栈

    是否稳定排序算法:否 (如:[ 4, 2, 3, 2] -> [2, 2, 3, 4])这里的 4 - 2 交换,导致原有的 2、2排序被打乱。

    堆排序

    新建堆然后从堆中逐条取出元素。

    具体算法实现(python)如下图:

    5a8f4219986f9591a1e520458d6797b8.png

    时间复杂度:平均 O(nlogn) 最优 O(nlogn) 最差 O(nlogn)

    空间复杂度:O(logn) - 递归堆栈

    是否稳定排序算法:否

    其它

    完全二叉树:完全二叉树的根节点到倒数第二层节点满足完美二叉树,最后一层节点可以不完全填充,但满足靠左对齐。

    堆:一种树状数据结构,需要满足如下性质:

    1. 堆中的某个节点的值总是大于等于或小于等于其父节点的值;

    2. 堆总是一颗完全二叉树;

    归并排序

    建立在归并操作基础上的一种有效排序方式,采用分治法:

    1、分割:递归地把当前序列平均分割成两半。

    2、集成:将上一步得到的有序子序列集成到一起(归并)。

    具体算法实现(python)如下图:

    b0b2757dd04be9def3682e889f1e4010.png

    时间复杂度:平均 O(nlogn) 最优 O(nlogn) 最差 O(nlogn)

    空间复杂度:O(logn)

    是否稳定性算法: 是

    其它

    归并操作:将两个有序集合合并成一个有序集合。

    希尔排序

    也称递减增量排序算法,是插入排序的一种更高效的改进版本。它是基于插入排序的一下两点性质改进点:

    1、插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率

    2、插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位

    即通过指定步长排序,使得原有序列变得尽可能有序,从而使得最后一步的插入排序的效率极大提升,从而使得总排序时间高效。

    具体算法实现(python,这里使用的递归 n/2 的步长)如下图:

    ca8b7af0ec041e170d7b01b7e1db552b.png

    时间复杂度:平均 O(nlogn) 最差 O(n^2)

    空间复杂度:O(1)

    是否稳定算法:是(上述代码实现是,有些版本可能不是)

    实现代码:

    https://github.com/zdxu/data-structure-and-algorithm/tree/master/sort_algorithm

    展开全文
  • 题目描述: Excel可以对一组纪录按任意指定列排序。现请你编写程序实现类似功能。 对每个测试用例,首先输出1行“Case i:”,其中 i 是测试用例的编号(从1开始)...当 C=2时,按姓名的非递减字典序排序;当 C=...

    http://ac.jobdu.com/problem.php?pid=1023

    题目描述:

        Excel可以对一组纪录按任意指定列排序。现请你编写程序实现类似功能。

        对每个测试用例,首先输出1行“Case i:”,其中 i 是测试用例的编号(从1开始)。随后在 N 行中输出按要求排序后的结果,即:当 C=1 时,按学号递增排序;当 C=2时,按姓名的非递减字典序排序;当 C=3
    时,按成绩的非递减排序。当若干学生具有相同姓名或者相同成绩时,则按他们的学号递增排序。

    输入:

        测试输入包含若干测试用例。每个测试用例的第1行包含两个整数 N (N<=100000) 和 C,其中 N 是纪录的条数,C 是指定排序的列号。以下有N行,每行包含一条学生纪录。每条学生纪录由学号(6位数字,同组测试中没有重复的学号)、姓名(不超过8位且不包含空格的字符串)、成绩(闭区间[0, 100]内的整数)组成,每个项目间用1个空格隔开。当读到 N=0 时,全部输入结束,相应的结果不要输出。

    输出:

        对每个测试用例,首先输出1行“Case i:”,其中 i 是测试用例的编号(从1开始)。随后在 N 行中输出按要求排序后的结果,即:当 C=1 时,按学号递增排序;当 C=2时,按姓名的非递减字典序排序;当 C=3
    时,按成绩的非递减排序。当若干学生具有相同姓名或者相同成绩时,则按他们的学号递增排序。

    样例输入:

    3 1

    000007 James 85

    000010 Amy 90

    000001 Zoe 60

    4 2

    000007 James 85

    000010 Amy 90

    000001 Zoe 60

    000002 James 98

    4 3

    000007 James 85

    000010 Amy 90

    000001 Zoe 60

    000002 James 90

    0 0

    样例输出:

    Case 1:

    000001 Zoe 60

    000007 James 85

    000010 Amy 90

    Case 2:

    000010 Amy 90

    000002 James 98

    000007 James 85

    000001 Zoe 60

    Case 3:

    000001 Zoe 60

    000007 James 85

    000002 James 90

    000010 Amy 90

     

    代码:

    # include<iostream>
    using namespace std;
     
    # include<string.h>
    # include<algorithm>//for STL
     
    struct Node
    {
        char number[7];
        char name[9];
        int score;
    };
     
    bool Cmp1(Node a, Node b)
    {
        return strcmp(a.number, b.number) < 0;
    }
    bool Cmp2(Node a, Node b)
    {
        if (strcmp(a.name, b.name) != 0)
        {
            return strcmp(a.name, b.name) < 0;
        }
        return strcmp(a.number, b.number) < 0;
    }
    bool Cmp3(Node a, Node b)
    {
        if (a.score != b.score)
        {
            return a.score < b.score;
        }
        return strcmp(a.number, b.number) < 0;
    }
     
    Node node[100000];
     
    int main()
    {
        int n, c, i, count = 1;
        //Node node[100000];
        while (cin >> n >> c)
        {
            if (n == 0)
            {
                return 0;
            }
            else
            {
                for (i = 0; i < n; i++)
                {
                    cin >> node[i].number >> node[i].name >> node[i].score;
                }
                 
                switch (c)
                {
                case 1:
                {
                          sort(node, node + n, Cmp1);
                          break;
                }
                case 2:
                {
                          sort(node, node + n, Cmp2);
                          break;
                }
                case 3:
                {
                          sort(node, node + n, Cmp3);
                          break;
                }
                }
     
                cout << "Case " << count++ << ":" << endl;
                for (i = 0; i < n; i++)
                {
                    cout << node[i].number << " " << node[i].name << " " << node[i].score << endl;
                }
            }
        }
        return 0;
    }
    /**************************************************************
        Problem: 1023
        User: mmcNuaa@163.com
        Language: C++
        Result: Time Limit Exceed
    ****************************************************************/
    View Code

     

    转载于:https://www.cnblogs.com/mmcmmc/p/3869116.html

    展开全文
  • 同样的预算,每年获得的点击量与曝光数量都呈现递减的状态,加上部分行业别的关键字竞价广告,需要更长期不断的投放,才会有明显的效果,于是有愈来愈多业主觉得,关键字竞价广告效益逐渐下滑,甚至无效。...
  • 排序

    2017-06-09 10:23:40
    排序,就是整理文件中的记录,使之按关键字递增(或递减)次序排列起来。 被排序的对象可以是文件或数据项。 排序的依据就是标识每个对象的关键字。对关键字进行排序,就相当于对关键字对应的文件进行排序。(有点...

    排序基本概念

    排序,就是整理文件中的记录,使之按关键字递增(或递减)次序排列起来。

    被排序的对象可以是文件或数据项。

    排序的依据就是标识每个对象的关键字。对关键字进行排序,就相当于对关键字对应的文件进行排序。(有点像数据库SQL中的主键。)

     

    排序的稳定性

    如果序列中有相同项,即有相同的关键字。那么就涉及到排序的稳定性的问题。

     

    排序后,相同值的项之间的相对次序没有发生变化,那么这个排序就是稳定的。

    如果,排序后相同值的项之间的相对次序发生了变化,则这种排序方法是不稳定的。

     

    不稳定的排序:

    选择排序,希尔排序,堆排序,快速排序;

     

    稳定的排序:

    冒泡排序,双向冒泡排序,插入排序,二叉树排序等。

     

    排序的分类

    排序算法都要有两个基本的操作:

    (1)比较项值的大小

    (2)改变指向项的指针或移动项值本身

     

    根据是否涉及数据的内、外存交换:

    如果在排序过程中,整个文件都放在内存中处理,排序时不涉及数据的内、外存交换,则称之为内部排序。

    否则,排序中涉及到数据的内外存交换,称之为外部排序。

     

     

    排序的性能评价

    标准:

    1.执行时间和所需的辅助空间

    2.算法本身的复杂度。

     

    空间复杂度:

    若算法所需的辅助空间并不依赖于问题的规模n,即辅助空间是O(1),则称之为就地排序。否则,非就地排序的辅助空间一般为O(n)。

     

    时间复杂度:

    1.平方阶排序O(n2):一般为简单排序,如插入排序,折半排序,选择排序和冒泡排序。

    2.线性对数排序O(nlogn)排序:如快速,归并,堆排序。

    3.O(n1+ε)阶排序:ε是介于0和1之间的常数,即0<ε<1,如希尔排序。

    4.线性阶排序O(n):如桶,箱,和基数排序。

     

    简单排序中插入排序最好,快速排序最快。

    若n较小(n<50),可以采用插入排序和选择排序。

    若n较大,则应采用时间复杂度为O(nlogn)的排序方法:快速排序,堆排序,归并排序。

     

     

    平均角度而言,哈希表获取任意一个指定值是最快的。->查找用哈希。或是链表。

    因为哈希表需要的额外存储空间多。付出了高额外空间的代价,理应获得高性能。

    哈希函数,不管怎么样,都是输入键值对,输出桶编号。

     

     

    二分查找法:

    已知一个有序序列,找出指定元素的方法。

    1.定义三个指针:low, mid, high,分别指向元素所在范围的下界、中间、上界。Mid=(high+low)/2

    2.让元素与mid比较,若相等,返回mid;

    若关键字小于mid对应的数,则high=mid-1,继续递归循环;

    若关键字大于mid对应的数,则low=mid+1,继续递归循环;

    3.直到找到所在位置。

     

     

    冒泡法

    冒泡排序和快速排序都是属于交换排序:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止。

     

    public static voidbubble(int[] a){

    boolean exchange;//交换标志。

    for(inti=0 ;i<a.length-1; i++){

    exchange= false;

    for(intj=0; j<a.length-1-i; j++){

    if(a[j]>a[j+1]){

    inttemp= a[j];

    a[j]=a[j+1];

    a[j+1]=temp;

    exchange = true;//发生了交换,故将交换标志置为true

    }

    }

    if(!exchange){//本次排序未发生交换,提前终止算法。

    return;

    }

    }

    for(intk=0;k<a.length; k++){

    System.out.print(a[k]+"");

    }

    }

     

     

    选择排序

    首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,放到排序序列的末尾。以此类推,直到所有的元素均排序完毕。

    public static voidchoice(int[] a){

    for(inti=0 ;i<a.length-1; i++){

    for(intj=i+1; j<a.length; j++){

    if(a[i]>a[j]){

    inttemp= a[j];

    a[j]=a[i];

    a[i]=temp;

    }

    }

    }

    for(intk=0;k<a.length; k++){

    System.out.print(a[k]+"");

    }

    }

     

     

    插入排序

    1.从第一个元素开始,认为已经排序了;

    2.取下一个元素,在已经排序的元素序列中从后向前扫描;

    3.如果前者大于后者,则交换二者位置;

    4.重复步骤3,直到前面的小于等于后面的;

    5.把原始序列的指针向后移一位,重复步骤2。

     

    public static voidinsert(int[] a){

    for(inti=0 ;i<a.length; i++){

    for(intj=i; j>0 ; j--){

    if(a[j]<a[j-1]){

    inttemp= a[j];

    a[j]=a[j-1];

    a[j-1]=temp;

    }

    }

    }

    for(intk=0;k<a.length; k++){

    System.out.print(a[k]+"");

    }

    }

     

     

    希尔排序

    1.通过设定的增量值,将数据进行分组;

    2.然后对每一组数据进行排序(每组的排序其实就是插入排序);

    3.增量不断变化,直至为1(要求最后一个增量必须为1);

    4.每组数据排好后,整体序列自然有序了。

     

    public static voidshell(int[] a){

     

    for(intincrement = a.length/2; increment>0; increment/=2){

    for(inti=increment; i<a.length; i++){

    for(intj=i; j>=increment ; j-=increment){

    if(a[j]<a[j-increment]){

    inttemp= a[j];

    a[j]=a[j-increment];

    a[j-increment]=temp;

    }

    }

    }

    }

    for(intk=0;k<a.length; k++){

    System.out.print(a[k]+"");

    }

    }

     

     

    快速排序

        快速排序采用分治策略。分治法的基本思想是:将原问题分为若干个规模更小但结构相似的子问题,递归地求解这些子问题,然后将这些子问题的解组合为原问题的解。

    具体思路见5月8日笔记。

     

    快排具体思路

    以这个思路为准。

    1. 设置两个变量i,j,其初值分别为low和high。分别表示待排序序列的起始下标和终止下标。

    2.将第i个记录当做枢纽元。即定义pivot=r[i]。

    3.从下标为j的位置开始由后向前依次搜索,当j位置处的元素值比枢纽元pivot的值小时,把该元素向前移动到下标为i的位置上,然后i=i+1;

    4.从下标为i的位置开始由前向后依次搜索,当找到第1个比pivot的值大的元素时,把该元素向后移动到下标为j的位置上;然后j=j-1;

    5.重复第3,4步,直到i==j为止。

    6.r[i]=pivot;

    7.进行一趟快速排序后,再分别对枢纽元分割所得的两个子序列进行快速排序,递归进行。

     

    算法的框架为:

    public static voidQuickSort(int[] a,int low, int high){

    //对a[...]进行排序

    int index= (low + high)/2;//枢纽元所在的位置

    if(low<high){//仅当区间长度大于1时才需排序

    Partition(a, low , high);//对a[]进行划分,元素具体怎么换位

    QuickSort(a, low, index-1);//一次划分结束后,对枢纽元左边的序列进行递归排序。

    QuickSort(a, index+1, high);//对枢纽元右边的序列进行递归排序。

     

    }

    }

     

    public static voidPartition(int[] a, int low, int high) {

    1.把枢纽元和最右边的元素互换位置。

    2.给数组第一个元素一个index,i;给数组倒数第二个元素一个index,j。

    3.把i向右移,直到碰到元素的值大于等于枢纽元为止。

    4.把j向左移,直到碰到元素的值小于等于枢纽元为止。

    5.当i和j交错后,也停止移动。

    6.最后一步就是将枢纽元与i所指向的元素互换位置。

    在这个第一阶段就实现了把所有比枢纽元小的元素都移到枢纽元的左边;把所有比枢纽元大的元素都移到枢纽元的右边。

    }

     

    快排具体实现

    public static voidqSort(int[] arr, int low, int high){

    //快排入口

    if(low<high){

    intpivot = Partition(arr, low, high);

    qSort(arr,low, pivot-1);

    qSort(arr,pivot+1, high);

    }

    }

     

    public static intPartition(int[] arr, int i, int j){

    //一趟快排

    intpivot = arr[i];

    while(i<j){

    while(i<j&& pivot<arr[j]){

    j--;

    }

    if(i<j){

    arr[i]= arr[j];

    i++;

    }

    while(i<j&& arr[i]<pivot){

    i++;

    }

    if(i<j){

    arr[j]= arr[i];

    j--;

    }

    }

    arr[i]= pivot;

    returni;

    }

     

     

     

     

     

    归并排序

    将两个已经排序好的序列合并成一个序列。

    详细内容见5月8日笔记。

    注意:归并排序的空间复杂度为O(n)。因为多引入一个数组,所以需要长度为n的额外存储空间嘛。

     

     

     

    堆排序

    1.堆排序中使用到二叉堆的结构性质:

    二叉堆是一棵被完全填满的二叉树,底层例外。就是有些叶子节点可能没有。底层上的元素是从左至右填充的。就是缺的话,也是右边的缺。

    可以用一个数组来表示二叉堆的节点存储情况:

    对数组中任一位置i上的元素,其左儿子在位置2i上,右儿子在左儿子后面的单元(2i+1)中,它的父亲则在位置|_i/2_|上。

    2.涉及到的二叉堆的堆序性质:

    小顶堆性质:

    堆中,对于每一个节点X,X的父亲中的关键字都不大于X的关键字,根节点除外。

    由这个性质,最小元总可以在根处找到。

    大顶堆性质与其相反,根结点处元素的值最大。

     

    又考虑到deleteMin这个方法。最小元可以肯定是在根处,用deleteMin方法从堆中删去最小元后,堆缩小。从而数组的最后一个单元可以存放刚刚删去的元素。依次理论一直往下走,最终,原数组将以递减的次序排列这些元素。

    想递增的排列,deleteMin换成deleteMax就行了。

     

    因为deleteMin方法花费时间O(logn),对N个元素操作一遍,总的运行时间是O(nlogn)。

     

     

    堆排序两步走:

    1.首先构建一个大顶堆或小顶堆出来。

    建堆时是从N/2-1的位置从后往前进行筛选。父结点和两个孩子结点比较。

    2.堆代表的二叉树数组的根结点和数组的最后一个结点交换位置。如此循环进行,直到二叉树剩下一个结点为止。

     

    如果是大顶堆,堆排序后是升序排序。如果是小顶堆,堆排序后是降序排序。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 排序代码

    2013-01-13 11:48:33
    实验要求:用堆排序算法按关键字递减的顺序排序。 程序输入:待排序记录数(整数)和待排序记录(整数序列); 程序输出:建堆结果和建堆后第一、第二次筛选结果。(注:待排序记录数大于等于3)
  • 对数据元素集合建立某种有序排列的过程称为排序。本章主要介绍一些常用的排序算法:...这里介绍的排序算法都是基于待排序的数据元素序列构成的线性表采用顺序存储结构,即采用数组存储,并且默认为按关键字递减排序
  • 排序

    2018-01-08 22:23:11
    成绩 10 开启时间 2017年11月22日 星期三 08:00 折扣 0.8 折扣时间 2017年12月15日 星期五 23:55 ...实验要求:用堆排序算法按关键字递减的顺序排序。 程序输入:待排序记录数(整数)和待
    成绩 10 开启时间 2017年11月22日 星期三 08:00
    折扣 0.8 折扣时间 2017年12月15日 星期五 23:55
    允许迟交 关闭时间 2018年01月8日 星期一 23:55

    实验要求:用堆排序算法按关键字递减的顺序排序

    程序输入:待排序记录数(整数)和待排序记录(整数序列);

    程序输出:建堆结果和建堆后第一、第二次筛选结果。(注:待排序记录数大于等于3

      测试输入关于“测试输入”的帮助 期待的输出关于“期待的输出”的帮助 时间限制关于“时间限制”的帮助 内存限制关于“内存限制”的帮助 额外进程关于“{$a} 个额外进程”的帮助
    测试用例 1 以文本方式显示
    1. 6↵
    2. 11↵
    3. 12↵
    4. 16↵
    5. 14↵
    6. 15↵
    7. 10↵
    以文本方式显示
    1. 16 15 11 14 12 10 ↵
    2. 15 14 11 10 12 ↵
    3. 14 12 11 10 ↵
    1秒 64M 0
    测试用例 2 以文本方式显示
    1. 9↵
    2. 9↵
    3. 8↵
    4. 7↵
    5. 6↵
    6. 5↵
    7. 4↵
    8. 3↵
    9. 2↵
    10. 1↵
    以文本方式显示
    1. 9 8 7 6 5 4 3 2 1 ↵
    2. 8 6 7 2 5 4 3 1 ↵
    3. 7 6 4 2 5 1 3 ↵
    1秒 64M 0
    #include<stdio.h> 
     
    int heap[100]; 
    int size; 
    void print(int index) 
    { 
      for (int i = 1; i <= index; i++) 
        { 
              printf("%d ",heap[i]); 
     } 
      printf("\n"); 
    } 
    void tiaozheng(int index) 
    { 
        int i, child; 
       
       for (i = index; 2 * i <= size; i = child) 
       { 
          child = 2 * i; 
         if (child != size&&heap[child + 1] > heap[child]) 
               child++; 
           if (heap[child] > heap[i]) 
     
         { 
                int tmp = heap[i]; 
               heap[i] = heap[child]; 
             heap[child] = tmp; 
         } 
      } 
    } 
     
    void Delete() 
    { 
       int i, child; 
      int maxenode = heap[1]; 
        int lastnode = heap[size--]; 
       for (i = 1; 2 * i <= size; i = child) 
       { 
          child = 2 * i; 
         if (child != size&&heap[child + 1] > heap[child]) 
               child++; 
           if (heap[child] > lastnode) 
             heap[i] = heap[child]; 
         else 
               break; 
     } 
      heap[i] = lastnode; 
    } 
    int main() 
    { 
     heap[0] = 100; 
     //freopen("1.txt", "r", stdin); 
        int node; 
      scanf("%d",&size); 
     int i = 1; 
     while (scanf("%d", &node) != EOF) 
      { 
          heap[i++] = node; 
      } 
      //建堆 
       for (i = size/ 2; i>=1; i--) 
        { 
          tiaozheng(i); 
      } 
      print(size); 
       Delete(); 
      print(size); 
       Delete(); 
      print(size); 
       return 0; 
    }  



    展开全文
  • 排序算法

    2019-07-16 23:22:14
    1.排序算法 ...kp2≤……≤kpn(非递减或非递增)关系,即使得序列成为一个按关键字有序的序列 {rp1,rp2,……,rpn},这样的操作就称为排序。 对一序列对象根据某个关键字进行排序。 多个关键字排序最...
  • 3. 堆排序

    2019-03-30 00:08:52
    成绩 10 开启时间 2018年11月25日 星期日 18:00 折扣 ... 实验要求:用堆排序算法按关键字递减的顺序排序。 程序输入:待排序记录数(整数)和待排序记录(整数序列); 程序输出:...
  • 第9章_排序

    2017-10-09 18:00:18
    更确切地说,排序是把一个数据元素序列整理成按关键字递增(或递减)排列的过程。 关键字分主关键字和次关键字两种。对要排序的数据元素集合来说,如果关键字满足数据元素值不同时该关键字的值也一定不同,这样的...
  • 本节内容 基数排序 (Radix Sort) 王道考研/ 基数排序 520 211 438 888 007 111 985 666 996 233 168 第趟以个位进分配 Q9 Q8 Q7 Q6 Q5 Q4 Q3 Q2 Q1 Q0 要求得到按关键字递减的有序序列 王道考研/ 基数排序 211 438 ...
  • 20. 堆排序

    2017-12-15 16:46:21
    实验要求:用堆排序算法按关键字递减的顺序排序。 程序输入:待排序记录数(整数)和待排序记录(整数序列); 程序输出:建堆结果和建堆后第一、第二次筛选结果。(注:待排序记录数大于等于3) 测试用例: ...
  • 各种排序算法的对比

    2017-07-03 22:19:00
    起泡排序是一种简单的交换排序,它通过对无序序列区中的相邻记录的关键字进行“比较”和记录位置的“交换”,以实现关键字较小的记录向“一头”漂移,而关键字较大的记录向“另一头”下沉,从而达到记录按关键字非...
  • kp2≤……≤kpn(非递减或非递增)关系,即使得序列成为一个按关键字有序的序列 {rp1,rp2,……,rpn},这样的操作就称为排序。 1、对一序列对象根据某个关键字进行排序 2、多个关键字排序...
  • 实验要求:用堆排序算法按关键字递减的顺序排序。 程序输入:待排序记录数(整数)和待排序记录(整数序列); 程序输出:建堆结果和建堆后第一、第二次筛选结果。(注:待排序记录数大于等于3) 测试...
  • 关于排序算法

    2015-07-16 16:00:32
    排序就是根据记录关键字值得递增或递减顺序将记录的次序进行重新排列使得原来一组次序任意的记录转变为按关键字有序排列的一组记录。如含有n个记录的文件为{R1,R2,R3……},记录对应的关键字值{k1,k2,k3……},确定一...
  • 排序排序算法之插入排序

    千次阅读 2011-03-03 21:54:00
    所谓排序,就是要将一堆记录,使之按关键字递增(或递减)次序排列起来。根据排序所采用的策略,可以分为如上五种: 1、插入排序(直接插入排序、希尔排序); 2、交换排序(冒泡排序、快速排序); 3、选择排序...
  • 1 排序的基本概念 ... 所谓排序,就是整理表中的元素,使之按关键字递增或递减的顺序排列。  1.2 排序的稳定性  当待排序元素的关键字各不相同时,排序的结果是唯一的,否则排序的结果不一定唯一。 ...
  • 确定一种排序规则,使用相应的关键字满足排序规则,例如递增、递减。使得到序列成为一个按关键字有序的序列,这样得出操作成为排序 排序的分类 内排序:是在排序整个过程中,待排序的所有记录全部被放置在内存中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 837
精华内容 334
关键字:

关键字递减排序