精华内容
下载资源
问答
  • 对下列四种排序方法,在排序中关键字比较次数同记录初始排列无关的是() A直接插入 B折半插入 C快速排序 D归并排序   直接插入排序很明显,在完全有序的情况下每个元素只需要与他左边的元素比较一次就可以确定他...

    对下列四种排序方法,在排序中关键字比较次数同记录初始排列无关的是()

    A直接插入
    B折半插入
    C快速排序
    D归并排序

     

    直接插入排序很明显,在完全有序的情况下每个元素只需要与他左边的元素比较一次就可以确定他最终的位置;

    折半插入排序,比较次数是固定的,与初始排序无关;

    快速排序,初始排序不影响每次划分时的比较次数,都要比较n次,但是初始排序会影响划分次数,所以会影响总的比较次数;

    归并排序在归并的时候,如果右路最小值比左路最大值还大,那么只需要比较n次,如果右路每个元素分别比左路对应位置的元素大,那么需要比较2*n-1次,所以与初始排序有关。


    归并排序
    假设二路归并
    1234
    12  34   2次
    2<4  2<3  2次   不用再继续  共4次
    1 2 3 4 有序

    2314 
    23  14  2次
    3<4  3>1  2次   再用2比较
    2>1       1次   插入
    1 2 3 4 有序  共5次

    可见归并排序的比较次数就不固定,随着初始状态不同而不同

    展开全文
  • 数组排序四种方法

    千次阅读 2018-11-26 11:36:49
    一)通过Arrays类的静态sort()方法,实现数组进行排序,sort()方法提供了多种重载形式,可任意类型的数组进行升序排序。 语法如下: Arrays.sort(object) //其中,object是指进行排序的数组名称。 算法实例...

    在程序设计中,经常需要将一组数列进行排序,这样更加方便与统计与查询。这篇博客,我就来介绍几种关于数组排序的方法。

    一)通过Arrays类的静态sort()方法,实现对数组进行排序,sort()方法提供了多种重载形式,可对任意类型的数组进行升序排序。

    语法如下:

    Arrays.sort(object)     //其中,object是指进行排序的数组名称。

    算法实例:

    import java.util.Arrays;        //导入java.util.Arrays类
    
    public class Demo1 {
        public static void main(String[] args) {
            int arr[]=new int[]{5,25,1,77};
            Arrays.sort(arr);       //运用sort()方法进行排序
            for(int i=0 ; i<4 ; i++){ //循环遍历排序后的数组
                System.out.print(arr[i]+" "); //将排序后的数组的各个元素进行输出
            }
        }
    }

    运行结果:

    上述实例是对整形数据进行排序,Java中的String类型数组的排序算法,是根据字典编排顺序排序的,因此数字排在字母前边,大写字母排在小写字母前面。

     二)冒泡排序:这是广大学习者最先接触的一种排序算法,它排序数组元素的过程总是将小数往前放、大数往后放,类似于水中气泡往上升的动作,所以称冒泡排序。

    基本思想:冒泡排序的基本思想是对比相邻的元素值,如果满足条件就交换元素值,把较小的元素移动到数组前面,把大的元素移动到数组后面(也就是交换两个元素的位置),这样较小的元素就像气泡一样从底部上升到顶部。

    算法实例:

    public class Demo2 {
        public static void main(String[] args) {
            int array[]={55,88,78,12,3,1};
            Demo2 demo2=new Demo2();
            demo2.sort(array);   //调用后面的排序方法将数组进行排序
        }
        /**
         * 冒泡排序
         * 
         * @param array
         *          要排序的数组
         */
        public void sort(int[] array){
            for(int i=1 ; i<array.length;i++){
                //比较两个相邻的元素,较大的数往冒泡
                for(int j=0;j<array.length-i;j++){
                    if(array[j]>array[j+1]){
                        int temp=array[j];   //第一个元素存于临时变量temp中
                        array[j]=array[j+1]; //第二个元素保存在第一个元素单元中
                        array[j+1]=temp;  //把临时变量(也就是第一个元素原值)保存在第二个元素单元
                    }
                }
            }
            showArray(array);    //输出冒泡排序后的数组
        }
        /**
         * 显示数组胡所有元素
         * 
         * @param  array
         *          要显示的数组
         */
        public void showArray(int[] array){
            for(int i:array){                    //遍历数组
                System.out.print(">"+i);         //输出每个数组的元素值
            }
            System.out.println();
        }
    }

    运行结果:

    冒泡排序的主要思想就是:把相邻两个元素进行比较,如满足一定条件则进行交换(如判断大小或日期前后等),每次循环都将最大(或最小)的元素排在最后,下一次循环是对数组中其他元素进行类似操作。

    三)直接选择排序:直接选择排序属于选择排序的一种,它的排序速度要比冒泡排序快一些,也是常用的排序算法。

    基本思想:将指定排序位置与其他数组元素分别对比,如果满足条件就交换元素值,注意这里区别冒泡排序,不是交换相邻元素,而是把满足条件的元素与指定的排序位置交换。

    算法实例:

    /**
     * 直接选择排序算法实例
     */
    
    public class Demo2 {
        public static void main(String[] args) {
            int array[]={22,45,85,1,2,0,32};
            Demo2 demo2=new Demo2();
            demo2.sort(array);  //调用后面的排序方法
        }
        /**
         * 直接选择排序
         * 
         * @param array
         *          要排序的数组
         */
        public void sort(int[] array){
            int index;
            for(int i=1 ; i<array.length;i++){
                index=0;
                for(int j=0;j<array.length-i;j++){
                    if(array[j]>array[index]){
                        index=j;  //找出本次循环数组中最大的元素的位置
                    }
                }
                //交换在位置array.length-i和index(最大值)上的两个元素
                int temp=array[array.length-i];
                array[array.length-i]=array[index];
                array[index]=temp;
            }
            showArray(array);
        }
        /**
         * 显示数组胡所有元素
         * 
         * @param  array
         *          要显示的数组
         */
        public void showArray(int[] array){
            for(int i:array){
                System.out.print(">"+i);
            }
            System.out.println();
        }
    }
    

    运行结果:

    将直接选择排序算法与冒泡排序算法相比较,我们可以看出,冒泡排序是交换满足条件的相邻元素值,而直接选择排序则是先找大最大(或最小)元素值的位置,然后与相应位置的元素进行交换。

    四)反转排序:顾名思义,反转排序就是以相反的顺序把原数组的内容进行重新排序。

    基本思想:把数组最后一个元素与第一个元素进行替换,倒数第二个与第二个元素进行替换,以此类推,直到把所有元素反转替换。

    算法实例:

    /**
     * 反转排序算法实例
     */
    
    public class Demo2 {
        public static void main(String[] args) {
            int array[]={1,2,3,4,5,6,7,8,9,10};
            Demo2 demo2=new Demo2();
            demo2.sort(array);
        }
        /**
         * 反转排序
         * 
         * @param array
         *          要排序的数组
         */
        public void sort(int[] array){
            System.out.println("数组原有内容:" );
            showArray(array);
            int temp;
            int len=array.length;
            for(int i=0; i<len/2;i++){
               temp=array[i];
               array[i]=array[len-1-i];
               array[len-1-i]=temp;
            }
            System.out.println("数组反转后内容:");
            showArray(array);
        }
        /**
         * 显示数组胡所有元素
         * 
         * @param  array
         *          要显示的数组
         */
        public void showArray(int[] array){
            for(int i:array){
                System.out.print("\t"+i);
            }
            System.out.println();
        }
    }
    

    运行结果:

    最后,需要注意的是,数组的下标都是从0开始的,最后一个元素的表示总是“数组名.length-1”。

    展开全文
  • 下列哪个算法是一个list排序的最快方法() 快速排序 冒泡排序 二分插入排序 线性排序
  • 列表中元素的几种排序方法

    千次阅读 2019-06-30 11:54:27
    一般的排序方法sort(),属于python的内置方法 names = ['alice','Bob','coco','Harry'] print(names.sort()) 将列表打乱 li = list(range(10)) import random random.shuffle(li) print(li) ...

    一般的排序方法sort(),属于python的内置方法

    names = ['alice','Bob','coco','Harry']
    print(names.sort())
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    将列表打乱

    li = list(range(10))
    import random
    random.shuffle(li)
    print(li)
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 常见的几种排序方法

    千次阅读 2019-06-01 09:34:54
    【常见的几种排序方法】 1.背景介绍 在计算机科学与数学中,一个排序算法(英语:Sorting algorithm)是一能将一串资料依照特定排序方式进行排列的一算法。 最常用到的排序方式是数值顺序以及字典顺序。有效的...

    【常见的几种排序方法】

    1.背景介绍

    在计算机科学与数学中,一个排序算法(英语:Sorting algorithm)是一种能将一串资料依照特定排序方式进行排列的一种算法。 最常用到的排序方式是数值顺序以及字典顺序。有效的排序算法在一些算法(例如搜寻算法与合并算法)中是重要的, 如此这些算法才能得到正确解答。 排序算法也用在处理文字资料以及产生人类可读的输出结果。 基本上,排序算法的输出必须遵守下列两个原则:
    输出结果为递增序列(递增是针对所需的排序顺序而言)
    输出结果是原输入的一种排列、或是重组
    虽然排序算法是一个简单的问题,但是从计算机科学发展以来,在此问题上已经有大量的研究。 更多的新算法仍在不断的被发明。

    2.知识剖析

    查找和排序算法是算法的入门知识,其经典思想可以用于很多算法当中。因为其实现代码较短,应用较常见。 所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗,只要熟悉了思想,灵活运用也不是难事。 一般在面试中最常考的是快速排序和归并排序,并且经常有面试官要求现场写出这两种排序的代码。 对这两种排序的代码一定要信手拈来才行。还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。
    常见的几种算法:
    ①冒泡算法
    ②选择排序
    ③插入排序
    ④快速排序

    3.常见问题

    问题一:各种排序算法用JavaScript 如何实现?
    问题二:各种排序算法的优劣及其应用?
    4.解决方案
    问题一:各种排序算法用JavaScript 如何实现?
    问题二:各种排序算法的优劣及其应用?

    4.解决方案、

    冒泡排序
    冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素, 如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有元素再需要交换, 也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
    冒泡排序演算法的运作如下:
    比较相邻的元素。如果第一个比第二个大,就交换他们两个。
    对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
    针对所有的元素重复以上的步骤,除了最后一个。
    持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
    代码实现:

    Array.prototype.bubbleSort = function () {
    var i, j, temp;
    for (i = 0; i < this.length - 1; i++)
    for (j = 0; j < this.length - 1 - i; j++)
    if (this[j] > this[j + 1]) {
    temp = this[j];
    this[j] = this[j + 1];
    this[j + 1] = temp;
    }
    return this;
    };

    var num = [22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70];//定义一个数组
    num.bubbleSort();//数组调用冒泡排序算法

    选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。 首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素, 然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。 选择排序的思想其实和冒泡排序有点类似,都是在一次排序后把最小的元素放到最前面。但是过程不同, 冒泡排序是通过相邻的比较和交换。而选择排序是通过对整体的选择。

    Array.prototype.selectionSort = function() {
    var i, j, min;
    var temp;
    for (i = 0; i < this.length - 1; i++) {
    min = i;
    for (j = i + 1; j < this.length; j++)
    if (this[min] > this[j])
    min = j;
    temp = this[min];
    this[min] = this[i];
    this[i] = temp;
    }
    return this;
    };
    var num = [22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70]; //定义一个数组
    num.selectionSort(); //数组定义选择排序算法

    插入排序(英语:Insertion Sort)是一种简单直观的排序算法。它的 工作原理是通过构建有序序列,对于未排序数据, 在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序 (即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位, 为最新元素提供插入空间。
    1.从第一个元素开始,该元素可以认为已经被排序
    2.取出下一个元素,在已经排序的元素序列中从后向前扫描
    3.如果该元素(已排序)大于新元素,将该元素移到下一位置
    4.将新元素插入到该位置后

    Array.prototype.insertionSort = function () {
    for (var i = 1; i < this.length; i++) {
    var temp = this[i];
    var j = i - 1;
    //如果将赋值放到下一行的for循环内, 会导致在第13行出现j未声明的错误
    for (; j >= 0 && this[j] > temp; j–) {
    this[j + 1] = this[j];
    }
    this[j + 1] = temp;
    }
    return this;
    }
    var num = [22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70]; //定义一个数组

    num.insertionSort(); //数组调用插入排序算法

    快速排序
    快速排序(英语:Quicksort),又称划分交换排序(partition-exchange sort), 一种排序算法, 最早由东尼·霍尔提出。在平均状况下,排序n个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较, 但这种状况并不常见。事实上,快速排序通常明显比其他Ο(n log n)演算法更快, 因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。
    步骤为:
    从数列中挑出一个元素,称为"基准"(pivot),
    重新排序数列,所有比基准值小的元素摆放在基准前面,所有比基准值大的元素摆在基准后面(相同的数可以到任一边)。在这个分割结束之后,该基准就处于数列的中间位置。这个称为分割(partition)操作。
    递归地(recursively)把小于基准值元素的子数列和大于基准值元素的子数列排序。
    递归到最底部时,数列的大小是零或一,也就是已经排序好了。这个演算法一定会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。

    Array.prototype.quickSort = function () {
    var len = this.length;
    if (len <= 1)
    return this.slice(0);
    var left = [];
    var right = [];
    var mid = [this[0]];
    for (var i = 1; i < len; i++)
    if (this[i] < mid[0])
    left.push(this[i]);
    else
    right.push(this[i]);
    return left.quickSort().concat(mid.concat(right.quickSort()));
    };

    var arr = [5, 3, 7, 4, 1, 9, 8, 6, 2];
    arr = arr.quickSort();

    5.编码实战

    6.扩展思考

    各种排序算法的时间复杂度和空间复杂度
    算法优劣评价术语
    稳定性:
    稳定:如果 a 原本在 b 前面,而 a = b,排序之后 a 仍然在 b 的前面;
    不稳定:如果 a 原本在 b 的前面,而 a = b,排序之后 a 可能会出现在 b 的后面;
    排序方式:
    内排序:所有排序操作都在内存中完成,占用常数内存,不占用额外内存。
    外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行,占用额外内存。
    复杂度:
    时间复杂度: 一个算法执行所耗费的时间。
    空间复杂度: 运行完一个程序所需内存的大小。

    7.参考文献

    参考一:JavaScript 排序算法汇总

    展开全文
  • 下列排序方法中,不稳定的方法有 正确答案: C 你的答案: C (正确) 归并排序与基数排序 插进排序与希尔排序 堆排序与快速排序 选择排序与冒泡排序 添加笔记 收藏 纠错 这道题同:将一个从大...
  • 分别用Comparable和Comparator两个接口对下列四位同学的成绩做降序排序,如果成绩一样, 那在成绩排序的基础上按照年龄由小到大排序。 姓名(String)年龄(int)分数(float) liusan 20 90.0F lisi ...
  • C/C++中四种排序算法的时间空间复杂度

    千次阅读 多人点赞 2020-08-11 13:38:36
    C/C++中四种排序算法的时间空间复杂度 一.浅谈时间复杂度和空间复杂度 1.概念: 时间复杂度:就是说执行算法需要消耗的时间长短,越快越好。 空间复杂度:就是说执行当前算法需要消耗的存储空间大小,也是越少越好。...
  • 排序方法的比较

    千次阅读 2015-07-31 14:08:51
    首先给出各个排序方式的性能比较...排序方法的比较 类别 排序方法 时间复杂度 空间复杂度 稳定性 平均情况 最好情况 最坏情况 辅助存储 插入排序 直接插入 O(n2) O(n) O(n2) O(1)
  • 下列排序法中,最坏情况下的时间复杂度最低的是(C ) 希尔排序 A.快速排序 B.堆排序 C.冒泡排序 D.正确答案:C 题目解析: 堆排序最坏情况时间下的时间复杂度为 O(nlog2n) ;希尔排序最坏情况时间下的时间复杂度...
  • 述一排序的定义二内部排序和外部排序三内部排序方法的分类一什么是排序 排序是计算机内经常进行的一操作其目的是将一组无序的记录序列调整为有序的记录序列例如将下列关键字序列52, 49, 80, 36, 14, 58, 61, 23, ...
  • 八大排序算法

    万次阅读 多人点赞 2012-07-23 16:45:18
    排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。 当n较大,则...
  • Python list内置sort()方法用来排序,也可以用python内置的全局sorted()方法可迭代的序列排序生成新的序列。如果要读取文件夹下面的文件,成为一个列表,并将列表中的文件名进行排序,这里可以使用sort()函数...
  • 种排序算法

    万次阅读 2015-04-11 19:53:20
    排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。    当n较大...
  • 在C#的List集合操作中,有时候需要针对List集合进行排序操作,如果是List集合按照元素对象或者元素对象的某个属性进行倒序排序的话,可以使用OrderByDescending方法来实现,OrderByDescending方法属于List集合的...
  • 排序

    千次阅读 2013-07-08 16:22:43
    直接插入排序 排序过程 整个排序过程为n-1趟插入,即先将序列中第1个...用折半查找方法确定插入位置的排序叫折半插入排序. 算法描述 算法评价 时间复杂度:T(n)=O(n²) 空间复杂度:S(n)=O(1)
  • 常用排序算法

    千次阅读 2018-12-01 21:25:55
    ,冒泡排序 五,快速排序 六,直接选择排序 七,堆排序 八,归并排序 九,基数排序 排序分类: 1、插入排序:直接插入排序(InsertSort),二分插入排序,希尔排序(希尔排序) 2,选择排序:简单选择...
  • 最近复习了各种排序算法,记录了一下学习总结和心得,希望大家能有所帮助。本文介绍了冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序、计数排序、桶排序、基数排序9经典的排序算法。针对每种排序...
  • 数据结构的常用八种排序算法

    万次阅读 多人点赞 2018-04-14 12:02:23
    排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。   ...
  • 、堆排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 五、冒泡排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 六、快速排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 七..
  • 下列排序中,不可能是快速排序第二趟结果的是()【2019年全国试题10(2分)】 A. 5, 2, 16, 12, 28, 60, 32, 72 B. 2, 16, 5, 28, 12, 60, 32, 72 C. 2, 12, 16, 5, 28, 32, 72, 60 D. 5, 2, 12, 28, 16, 32, 72, ...
  • 按平均时间将排序分为四类: (1)平方阶(O(n2))排序  一般称为简单排序,例如直接插入、直接选择和冒泡排序; (2)线性对数阶(O(nlgn))排序  如快速、堆和归并排序;...各种排序方法比较 简单
  • 他首先将li对象放进数组,然后指定一个方法,告诉这个数组两个元素之间该怎么排序,具体的排序js引擎中已经定死了的,不用去关心了,只要在排序函数中,告诉Array,两个内容对象该怎么比较就可以了。 第二...
  • 八大排序算法(C语言实现)

    万次阅读 多人点赞 2021-05-09 13:50:26
    文章目录插入排序插入排序希尔排序选择排序选择排序排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
  • 四大排序分析与总结

    千次阅读 2017-07-26 21:26:59
    为了便于描述,在这篇博客里且将内部排序分为: 1.插入排序(直接插入和希尔) 2.交换排序(冒泡和快排) 3.选择排序(直接选择和堆排序) 4.归并排序 1.插入排序直接插入排序(Straight Insertion Sort)基本思想:...
  • FlexGrid控件排序方法

    千次阅读 2006-03-08 17:38:00
    然后设置排序方法即可,1为升序,2为降序。需要注意的是,如果数据量很大,排序之前可以先将FlexGrid控件设置为不可见,排序结束后再恢复为可见;或者SetRedraw(FALSE),排序后设置为TRUE。示例代码如下: m_...
  • 此题是美团2017春招实习生在线笔试题,题目是“如何判断有向图有没有回路”,这里给出两解法以供参考。解法一:深度遍历假设图以邻接矩阵表示,一条深度遍历路线中如果有结点被第二次访问到,那么有环。我们用一个...
  • 这里提供两种方法:选择法和冒泡法,依次实现对数组中整数的排序问题。一:所谓选择法就是先将 N 个数中最小的数与 a[0] 对换;再将 a[1] 到 a[N - 1] 中最小的数与 a[1] 对换 ...... 每比较一轮,找出一个未进排序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,202
精华内容 44,480
关键字:

对下列四种排序方法