欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

小试牛刀之sort()排序的实现

程序员文章站 2024-03-09 10:17:35
...

受大学室友的鼓动,我也打算利用公众平台来记录自己的前端知识积累,同时呢,自己总结的东西,总归会有局限性,希望小伙伴能给我指点迷津。知识就是一张巨大的网,作为一名摸不清头绪的入学者,唯一能做的事情就是吐好每一根丝,丝拧成线,线再织成网。好啦,开机仪式over,废话不多说了啦...


关于Sort()这个函数,决定研究它是因为在看阮老师的箭头函数时,最后有一个小练习:
请使用箭头函数简化排序时传入的函数:

var arr = [10, 20, 1, 2];
arr.sort((x, y) => {
    ???
});
console.log(arr); // [1, 2, 10, 20]

因为之前js基础也不扎实,没有get到这个题的核心,想了想写了写,最后放弃了,看了评论里的答案。我的天,就一句——return x - y;,当时我就觉得这个函数太神奇了,这么简单的解决了数组排序。(上大学那会,懒惰致死的我所有排序算法原理都明明白白,但是从来没有写过,于是就...后悔莫及阿)

sort()函数定义

了解原理先从函数定义入手,于是乎...从W3C上搬了一段解释:

定义和用法: sort() 方法用于对数组的元素进行排序。

语法: arrayObject.sort(sortby)

返回值: 对数组的引用。请注意,数组在原数组上进行排序,不生成副本。

说明:

  1. 如果调用该方法时没有使用参数,将按字母顺序对数组中的元素进行排序,说得更精确点,是按照字符编码的顺序进行排序。要实现这一点,首先应把数组的元素都转换成字符串(如有必要),以便进行比较。
  2. 如果想按照其他标准进行排序,就需要提供比较函数,该函数要比较两个值,然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b,其返回值如下:
    若 a 小于 b,在排序后的数组中 a 应该出现在 b 之前,则返回一个小于 0 的值。
    若 a 等于 b,则返回 0。
    若 a 大于 b,则返回一个大于 0 的值。

sort排序的过程中发生了什么呢

此处参考了前辈的文章链接描述,我就特别傻,断点打到sort()函数这一行,然后step-into执行,不断在console里打印arr。。。傻的一p
怎么查看sort()方法是如果实现排序的呢?我们可以在比较函数里把a,b及数组输出一下,看看是否能够看出使用的排序算法。

var arr=[1, 8, 3, 5, -1];
function compare(a,b){
    console.log(a,b,arr);
    return a-b;
}
arr.sort(compare);

控制台输出
1 8 [1, 8, 3, 5, -1]
8 3 [1, 8, 3, 5, -1]
1 3 [1, 8, 8, 5, -1]
8 5 [1, 3, 8, 5, -1]
3 5 [1, 3, 8, 8, -1]
8 -1 [1, 3, 5, 8, -1]
5 -1 [1, 3, 5, 8, 8]
3 -1 [1, 3, 5, 5, 8]
1 -1 [1, 3, 3, 5, 8]
[-1,1, 3, 5, 8]
*/
  第一次1和8比较,1<8,不需要调整位置。   

  第二次8和3比较,8>3,需要调整位置。但是这里没有交换位置,仅仅是8覆盖了3位置。这里就可以推断出不是单纯的使用了冒泡算法。
  第三是1和3比较,1<3,3替换了8的位置。什么鬼,几个意思???看到这里我也是表示不懂呀。那就继续往下看咯。   

  第四是8和5比较,8>5,又仅仅是覆盖,没有交换位置。还是不懂,继续往下!
  第五是3和5比较,3<5,5替换了8的位置,不懂,继续往下!   

  第六是8和-1比较,8>-1, 还仅仅是覆盖,继续往下!
  第七、八、九次,-1依次和5,3,1做了比较,并且5,3,1都移动了一次位置。

  我们得出了结论:sort()方法是使用的冒泡和插入两种方式结合进行排序的。

回顾冒泡和插入排序

这里我用自己的话总结一下:
冒泡排序:

  1. 第一轮:从第一个元素开始,相邻元素比较,前者比后者大,互换位置,下标加一;再继续相邻元素比较,大的元素移到后面,下标加一再比较...这样一轮比较下来,最后一个元素一定是数组里最大的元素
  2. 第二轮及之后:好啦,现在最后一个元素(即最大的元素)确定了,将其排除在外,我们再来从头对比除它之外的元素,将倒数第二大的元素移到倒数第二个位置。以此类推,每一轮确定一个元素的位置,就像小鱼吐泡泡一样,大的泡泡一点一点往上移
function bubbel(arr) {
    var len=arr.length;
    for(var i=0; i&lt;len; i++) {
        for(var j=0; j&lt;len; j++) {
            if(arr[j] &gt; arr[j+1]) {
                var temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    return arr;
}

插入排序:
1.第一轮:将第一个元素看成只有一个元素的有序数组,拿第二个元素和它比较,比它小就插到它前面,比它大就插到它后面。
2.第二轮:经过第一轮,前两个元素已为有序数组。再拿第三个元素和前两个元素比较,看插在哪合适。以此类推。一般会新建一个数组记录排序后的数组。

// 插入排序 从下标1开始每增1项排序一次,越往后遍历次数越多
function sort1(array) {
  var len = array.length,
      i, j, tmp, result;
  
  // 设置数组副本
  result = array.slice(0);
  for(i=1; i &lt; len; i++){
    tmp = result[i];
    j = i - 1;
    while(j&gt;=0 &amp;&amp; tmp &lt; result[j]){
      result[j+1] = result[j];
      j--;
    }
    result[j+1] = tmp;
  }
  return result;
}

sort()的正面目来啦

前面铺垫了这么多,终于到了今天的重点——冒泡排序和插入排序是如何混合使用的?即sort()实现的原理。先上我的代码!! 时隔多年,我终于不再懒惰,勇敢写出我的代码。希望努力不要太晚~

var arr = [1, 8, 3, 5, -1];
    var len = arr.length;
    function compareSet(temp, compare_i){
        for(var i = compare_i; i &gt; 0; i--){
            if(temp &gt; arr[i-1]){
                arr[i] = temp;
                break;
            }
            else{
                arr[i] = arr[i-1];
                arr[i-1] = temp;
            }
        }
    }
    for(var i = 0; i &lt; len; i++){
        if(arr[i] &gt; arr[i+1]){
            var temp = arr[i+1];
            arr[i+1] = arr[i];
            console.log(arr);            
            compareSet(temp, i);
        }
        
    }
    console.log(arr);

根据之前分析sort()排序控制台输出,先是像冒泡排序那样相邻的元素比较。但是,一旦出现需要换位置的操作时,不再是像插入排序那样直接交换。而是先用变量temp暂存arr[i+1],再将较大的arr[i]移到[i+1]位置上,对暂存变量temp使用插入排序,将其插入前0 ~ [i-1]有序数组中。把这个temp安排好,再继续之前的冒泡排序。
**冒泡排序是元素对调后这一轮就不管事了,要重复i-1轮冒泡。
插入排序是不管现有元素的顺序是否正确,都给你在已有序数组从头比较到尾。**
所以,混合起来666。

这里还有一个前辈写的sort()实现,我对比一下,我的运行速度18ms,前辈的25ms。其实我感觉我写的没有前辈的简洁,但不知道为什么我的快一些。之后再仔细研究研究。

            [function findMinIndex(arr,start){
                var iMin=arr\[start\];
                var iMinIndex=start;
                for(var i=start;i&lt;arr.length;i++){
                    if(iMin&gt;arr\[i\]){
                        iMin=arr\[i\];
                        iMinIndex=i;
                    }
                }
                return iMinIndex;
            }
            for(var i=0;i&lt;arr.length;i++){
                var n=findMinIndex(arr,i);
                var tem;
                tem=arr\[n\];
                arr\[n\]=arr\[i\];
                arr\[i\]=tem;
            }][1]

其实,写到这里,应该结束了!但是我忽然想起来,大学《数据结构》课上,我最喜欢的魏莱老师好像给我们说过这个混合排序算法的。老师一步步引导我们思考的场景还历历在目,我甚至都可以回想起老师说话时的语气。可是,我却还的差不多了,实在是可恶!!!

原文地址:https://segmentfault.com/a/1190000017026510

上一篇: CentOS8的基础防火墙配置

下一篇: