精华内容
下载资源
问答
  • 猴子排序算法 重点 (Top highlight)I was spending a lot of time lately thinking about how I can improve my program’s sorting performance a little bit more. I was thinking: 最近,我花了很多时间思考如何...

    猴子排序算法

    重点 (Top highlight)

    I was spending a lot of time lately thinking about how I can improve my program’s sorting performance a little bit more. I was thinking:

    最近,我花了很多时间思考如何才能提高程序的排序性能。 我刚在想:

    Hey, there are sorting algorithms that have proven themselves well and that everyone knows, but there must be something we all are missing, maybe?

    嘿,有一些排序算法已经很好地证明了自己,并且每个人都知道,但是一定有我们所有人都缺少的东西,也许吗?

    Well, I found something and I wasn’t wrong. There was something that we didn’t know much about, though it wasn’t exactly what I was looking for.

    好吧,我发现了一些东西,但我没看错。 尽管我并不是真正想要的东西,但我们并没有太多了解

    I found a really slow sorting algorithm called Monkey Sort aka Bogosort.

    我发现了一种非常慢的 排序算法,称为Monkey Sort aka Bogosort。

    Monkey Sort is based on Infinite Monkey Theorem:

    猴子排序基于无限猴子定理:

    The infinite monkey theorem is a popular demonstration of the mathematical probability, stating a monkey hitting keys at random on a typewriter keyboard, given enough time and typewriters, will eventually reproduce the entire works of William Shakespeare.

    无限猴子定理 是数学概率的流行示例,它说明猴子在打字机键盘上随机敲击键, 有足够的时间 和打字机,最终将重现威廉·莎士比亚的全部作品。

    From Wikipedia:

    从维基百科:

    while not isInOrder(deck):
    shuffle(deck)

    Algorithm implemented in Java:

    用Java实现的算法:

    import static java.util.Collections.shuffle;public List<Integer> monkeySort(List<Integer> list) {
    while (!list.equals(sortedList)) {
    shuffle(list);
    }

    return list;
    }

    We are shuffling the list until it’s sorted.

    我们正在整理列表,直到对其进行排序。

    Best scenario is O(N), if the list is already sorted. It’s not O(1) because it will take O(N) to find out the list is sorted.

    如果列表已经排序 最好的情况是O(N)。 它不是O(1),因为它需要O(N)才能找到已排序的列表。

    Worst scenario is O(∞) since this algorithm has no upper bound. But hey, even though it has no upper bound, it’s finite! We know it can’t be infinite from the infinite monkey theorem. We’ll get the result eventually. :)

    最糟糕的情况 O(∞),因为此算法没有上限。 UT斯达康哎,即使它没有上限, 它的有限的! E知道它不能从无限猴子定理是无限的 我们最终会得到结果。 :)

    Thank you for reading! ❤️

    感谢您的阅读! ❤️

    翻译自: https://medium.com/swlh/monkey-sort-algorithm-1ac5f5b15de1

    猴子排序算法

    展开全文
  • 具体分析如下:1 冒泡排序(BubbleSort)冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。它是O(n^2)的算法。步骤: ...

    常用排序算法的复杂度分析整理
    这里写图片描述
    具体分析如下:

    1 冒泡排序(BubbleSort)

    冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。它是O(n^2)的算法。

    步骤:
    (1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。
    (2)对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
    (3)针对所有的元素重复以上的步骤,除了最后一个。
    (4)持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

    详细原理及实现参照:冒泡排序原理及Java实现

    2 选择排序(SelectSort)

    选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。
    这种排序方法效率是 O(n2)。在实际应用中处于和冒泡排序基本相同的地位。它们只是排序算法发展的初级阶段,在实际中使用较少。

    详细原理及实现参照:选择排序原理及Java实现

    3 插入排序(InsertSort)

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

    详细原理及实现参照:插入排序原理及Java实现

    4 Shell排序(ShellSort)

    希尔排序,也称递减增量排序算法,是插入排序的一种高速而稳定的改进版本。希尔排序是基于插入排序的以下两点性质而提出改进方法的:
    (1)插入排序在对几乎已经排好序的数据操作时, 效率高, 即可以达到线性排序的效率
    (2)但插入排序一般来说是低效的, 因为插入排序每次只能将数据移动一位

    Shell排序通过将数据分成不同的组,先对每一组进行排序,然后再对所有的元素进行一次插入排序,以减少数据交换和移动的次数。平均效率是O(nlogn)。其中分组的合理性会对算法产生重要的影响。现在多用D.E.Knuth的分组方法。

    Shell排序比冒泡排序快5倍,比插入排序大致快2倍。Shell排序比起QuickSort,MergeSort,HeapSort慢很多。但是它相对比较简单,它适合于数据量在5000以下并且速度并不是特别重要的场合。它对于数据量较小的数列重复排序是非常好的。

    详细原理及实现参照:希尔排序原理及Java实现

    5 堆排序(HeapSort)

    堆排序适合于数据量非常大的场合(百万数据)。

    堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录,因为快速排序,归并排序都使用递归来设计算法,在数据量非常大的时候,可能会发生堆栈溢出错误。

    堆排序会将所有的数据建成一个堆,最大的数据在堆顶,然后将堆顶数据和序列的最后一个数据交换。接下来再次重建堆,交换数据,依次下去,就可以排序所有的数据。

    详细原理及实现参照:堆排序原理及Java实现

    6 归并排序(MergeSort)

    归并排序(Merge sort,台湾译作:合并排序)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用.
    归并排序先分解要排序的序列,从1分成2,2分成4,依次分解,当分解到只有1个一组的时候,就可以排序这些分组,然后依次合并回原来的序列中,这样就可以排序所有数据。合并排序比堆排序稍微快一点,但是需要比堆排序多一倍的内存空间,因为它需要一个额外的数组。

    步骤:
    (1)申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
    (2)设定两个指针,最初位置分别为两个已经排序序列的起始位置
    (3)比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
    (4)重复步骤3直到某一指针达到序列尾
    (5)将另一序列剩下的所有元素直接复制到合并序列尾

    详细原理及实现参照:归并排序原理及Java实现

    7 快速排序(QuickSort)

    快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见。事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环可以在大部分的架构上很有效率地被实现出来,且在大部分真实世界的数据,可以决定设计的选择,减少所需时间的二次方项之可能性。
    快速排序是一个就地排序,分而治之,大规模递归的算法。从本质上来说,它是归并排序的就地版本。快速排序可以由下面四步组成。

    (1) 如果不多于1个数据,直接返回。
    (2) 一般选择序列最左边的值作为支点数据。
    (3) 将序列分成2部分,一部分都大于支点数据,另外一部分都小于支点数据。
    (4) 对两边利用递归排序数列。

    快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法,但是就通常情况而言,没有比它更快的了。快速排序是递归的,对于内存非常有限的机器来说,它不是一个好的选择。

    详细原理及实现参照:快速排序原理及Java实现

    展开全文
  • 冒泡排序是最慢的排序算法之一, 也是最容易实现的排序算法.使用这种算法进行排序时,数据值会像气泡一样从数组的一端漂浮到另一端,所以称之为冒泡排序.假设要对数组按照升序排列,较大的值会浮动到数组的右侧,较小值会...

    基本排序算法:冒泡排序

    排序方式

    排序图片

    冒泡排序

    冒泡排序是最慢的排序算法之一, 也是最容易实现的排序算法.使用这种算法进行排序时,数据值会像气泡一样从数组的一端漂浮到另一端,所以称之为冒泡排序.假设要对数组按照升序排列,较大的值会浮动到数组的右侧,较小值会浮到左侧.

    原理

    简单来说就是相邻两个元素进行对比,按照你需要的排序方式(升序or降序)进行位置替换,替换时需要额外一个变量当作中间变量去暂存值。

    冒泡排序动图演示:

    实现方式:

    一、双重for循环

    两两对比进行替换

    function bubbleSort(arr) {
        console.time('第一种冒泡排序时间');
        var len = arr.length;
        for (var i = 0; i < len; i++) {
            for (var j = 0; j < len - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {        //相邻元素两两对比
                    var temp = arr[j+1];        //元素交换
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        console.timeEnd('第一种冒泡排序时间');
        return arr;
    }
    var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
    console.log(bubbleSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    //第一种冒泡排序时间: 0.065185546875ms
    
    二、while for循环

    设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

    function bubbleSort2(arr) {
        console.time('第二种冒泡排序时间');
        var i = arr.length-1;  //初始时,最后位置保持不变
        while ( i> 0) {
            var pos= 0; //每趟开始时,无记录交换
            for (var j= 0; j< i; j++){
                if (arr[j]> arr[j+1]) {
                    pos= j; //记录交换的位置
                    var tmp = arr[j]; arr[j]=arr[j+1];arr[j+1]=tmp;
                }
            }
            i= pos; //为下一趟排序作准备
        }
        console.timeEnd('第二种冒泡排序时间');
        return arr;
    }
    var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
    console.log(bubbleSort2(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    //第二种冒泡排序时间: 0.031005859375ms
    

    排序对比

    展开全文
  • 基本排序算法  这里主要介绍的基本排序算法主要包括: 冒泡排序,选择排序,插入排序,之后的文章会介绍希尔排序,快速排序等高级排序算法, 文章后面会对这几个算法进行性能比较.... 冒泡排序是最慢的排序算法之...

    基本排序算法

      这里主要介绍的基本排序算法主要包括: 冒泡排序,选择排序,插入排序,之后的文章会介绍希尔排序,快速排序等高级排序算法, 文章后面会对这几个算法进行性能比较.
    基本排序算法的核心思想是对一组数据按照一定的顺序重新排列. 重新排列主要就是嵌套的for循环. 外循环会遍历数组每一项,内循环进行元素的比较.
    注: 文中都以实现升序排序为例:

    1.冒泡排序

      冒泡排序是最慢的排序算法之一, 也是最容易实现的排序算法.使用这种算法进行排序时,数据值会像气泡一样从数组的一端漂浮到另一端,所以称之为冒泡排序.假设要对数组按照升序排列,较大的值会浮动到数组的右侧,较小值会浮到左侧.

    原理:

      从开始第一对相邻元素开始,对每一对相邻元素进行比较,如果第一个比第二个大,就交换它们两个, 这样直到最后一对元素比较结束,最后的元素就是最大的数,重复这个过程,就可以完成排序.

    示意图:

    代码:

          function bubbleSort(arr) {
            for (let i = 0; i < arr.length; i++) {
              for (let j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                  let temp = arr[j];
                  arr[j] = arr[j + 1];
                  arr[j + 1] = temp;
                }
              }
            }
            return arr;
          }

    2.选择排序

    原理:

      首先找出当前元素中最小的元素,并放到排序序列的起始位置,然后再从剩余的元素中寻找最小的元素,然后放到已排序序列的末尾。以此类推,直到排序完成。

    示意图:

    代码:

          function selectionSort(arr) {
            var len = arr.length;
            var minIndex, temp;
            for (var i = 0; i < len - 1; i++) {
              minIndex = i;
              for (var j = i + 1; j < len; j++) {
                if (arr[j] < arr[minIndex]) {
                  minIndex = j;
                }
              }
              temp = arr[i];
              arr[i] = arr[minIndex];
              arr[minIndex] = temp;
            }
            return arr;
          }

     

    3.插入排序

    原理:

      从第二个元素开始(假定第一个元素已经排序了),取出这个元素,在已经排序的元素中从后向前进行比较,如果该元素大于这个元素,就将该元素移动到下一个位置,然后继续向前进行比较,直到找到小于或者等于该元素的位置,将该元素插入到这个位置后.重复这个步骤直到排序完成.

    示意图:

    代码: 

          function insertionSort(arr) {
            var len = arr.length;
            var preIndex, current;
            for (var i = 1; i < len; i++) {
              preIndex = i - 1;
              current = arr[i];
              while (preIndex >= 0 && arr[preIndex] > current) {
                arr[preIndex + 1] = arr[preIndex];
                preIndex--;
              }
              arr[preIndex + 1] = current;
            }
            return arr;
          }

    4.基本排序算法的性能比较

      使用console.time进行时间计算,在需要测试的开始位置写上console.time,并且括号内传一个字符串。在结束的位置使用console.timeEnd方法,并再次把字符串传入,即可在控制台查看执行时间.
    首先创建一个n位随机数组用来测试.

          function createRandomArr(n) {
            let arr = [];
            for (let i = 0; i < n; i++) {
              arr.push(Math.floor((Math.random() * 100)));
            }
            return arr;
          }

    分别记录3种算法所用时间:

      var testArr = createRandomArr(1000);
      //  记录冒泡排序所用时间
      console.time('bubbleSort');
      bubbleSort(testArr);
      console.timeEnd('bubbleSort');
      var testArr = createRandomArr(1000);
      //  记录选择排序所用时间
      console.time('selectionSort');
      selectionSort(testArr);
      console.timeEnd('selectionSort');
      var testArr = createRandomArr(1000);
      //  记录插入排序所用时间
      console.time('insertionSort');
      insertionSort(testArr);
      console.timeEnd('insertionSort');

    在Chrome执行代码,在控制台看看他们的执行时间对比, Duang Duang Duang!

    当然, 要进行多次运行, 得到的结果才能被视为有效的结论. 很显然, 插入排序比其他两种排序方法快.

     

    注: 文中图片转自: https://www.cnblogs.com/onepixel/articles/7674659.html

     

    转载于:https://www.cnblogs.com/yuqing6/p/8862436.html

    展开全文
  • 基本排序算法

    2018-01-04 17:12:00
    冒泡排序,它是最慢的排序算法之一,但也是一种最容易实现的排序。 之所以叫冒泡排序是因为使用这种排序算法时,数据值会像气泡一样从数组的一端漂浮到另一端。假设长在将一组数字按照升序排列,较大的值会浮动到...
  • JS中算法之排序算法

    2019-01-23 00:12:00
    它是最慢的排序算法之一。 1、不断比较相邻的两个元素,如果前一个比后一个大,则交换位置。 2、当比较完第一轮的时候最后一个元素应该是最大的一个。 3、按照步骤一的方法进行相邻两个元素的比较,这个时候由于...
  • 基础排序算法

    2019-08-13 14:15:22
     最慢的排序算法,基本上只是作为教科书的教学素材,没多少实用价值。还有就是好多公司用作面试题。其思想是比较相邻的两个值,大的值往右(或左)移动。 public void BubbleSort() { int temp = 0; for (int ...
  • 常用排序算法

    2017-04-25 16:56:27
    冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。它是O(n^2)的算法。 步骤:  (1)比较相邻的元素。如果第一个比...
  • 冒泡排序算法,它是最慢的排序算法之一,但也是一种最容易实现的排序算法。之所以叫冒泡排序是因为使用这种排序算法排序时,数据值会像气泡一样从数组的一端漂浮到另一端。假设正在将一组数字按照升序排列,较大的...
  • 排序算法 ->冒泡排序

    2018-01-07 22:07:15
    冒泡排序之所以叫冒泡排序是因为在使用冒泡排序时,数据值会像气泡一样从数组的一端漂浮...它是最慢的排序算法之一,但也是一种最容易实现的排序算法. Array.prototype.bubbleSort = function () { var ary = this; fo
  • 1. 算法步骤 比较相邻元素。...4. 什么时候最慢 当输入数据是反序时(写一个 for 循环反序输出数据不就行了,干嘛要用你冒泡排序呢,我是闲吗)。 5. JavaScript 代码实现 function bubbleSort
  • 排序算法六:选择排序声明:引用请注明出处http://blog.csdn.net/lg1259156776/引言在我的博文《“主宰世界”的10种...系列博文的前五篇分别讲述了插入排序和交换排序,本文介绍直接选择排序这一似乎是最慢的排序算法
  • 排序算法总结

    2013-06-23 22:51:36
    排序算法总结 ...学习了这么多的排序算法,还...冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。它是O(n^2)的算法。
  •  冒泡排序是最慢的排序算法之一, 也是最容易实现的排序算法.使用这种算法进行排序时,数据值会像气泡一样从数组的一端漂浮到另一端,所以称之为冒泡排序.假设要对数组按照升序排列,较大的值会浮动到数组的右侧,较小值...
  • 排序算法总结分析(二)——常见八大排序算法

    千次阅读 多人点赞 2014-04-09 12:44:12
    又译为泡沫排序或气泡排序,冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。 冒泡排序算法的运作如下: 比较相邻的...
  • 排序算法总结JavaScript实现 前言: 查找和排序算法是算法的入门知识, 其中的经典思想可以用于很多... 冒泡排序是最简单的排序之一了,但也是最慢的排序算法之一,其大体思想就是通过与相邻元素...
  • 排序算法小结

    2017-06-28 11:03:00
    不稳定的排序算法:选择排序、快速排序、...复杂度为O(0)——这是最原始、最慢的排序算法 2、直接插入排序:O(n*n) 3、选择排序:O(n*n) 4、快速排序:平均时间复杂度log2(n)*n,所有内部排序方法中最高好的,大...
  • 8种排序算法总结

    2020-10-15 11:14:37
    冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较它是O(n ^ 2)的算法。 步骤: (1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。 (2)对每一对相邻元素作
  • 开始日期:2018/07/23 前言 近段时间一直在阅读《数据结构与算法...以下的冒泡排序就是基本排序算法,最慢的排序算法之一。 冒泡排序 最慢的排序算法之一,数据值会像气泡一样从数组的一端飘向另一端。之所以会...
  • 冒泡排序 冒泡排序是最慢的排序算法之一,数据值会像起跑一样从数组的一端漂浮到另一端 动画演示 js实现 var CArray = function () { this.dataStore = [9...
  • 排序算法总结

    2011-06-07 04:19:00
    学习了这么多的排序算法,还没有做个总结,呵呵 冒泡排序冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。它是O(n^2)的...
  • 常用排序算法的复杂度分析整理 ...冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。它是O(n^2)的算法。...
  • 前面提到冒泡排序,它是一种交换排序,堪称最慢的排序算法。可是,物极必反,快速排序是冒泡排序的升级加强版,同属于交换排序类。 以”空间“换时间,快速排序不是相邻元素的交换,而是加大了比较和交换的距离,...
  • 三、交换排序3.1 冒泡排序(1)基本思想 在要排序的一组数中,对当前还未排好序的范围内的全部数,...冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法 起泡排序平均时间复杂度为O(n2) (3)Java实现pa

空空如也

空空如也

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

最慢的排序算法