精华内容
下载资源
问答
  • 从小到大排序 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>...

    从小到大排序

    
    <!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    </head>
    
    <body>
        <script>
            var arr = [324, 7378755, 5, 4, 54545, 5, 544, 13, 1, 5555555, 54, 5654, 556, 5, 2, 63, 949, 454635, 49, 6, 31, 2, 1, 164, 4554, 2, 21, 15]
            for (var i = 0; i < arr.length; i++) {
                45
                for (var j = 0; j < arr.length - i - 1; j++) {
                    if (arr[j] > arr[j + 1]) {
                        var temp = arr[j]
                        arr[j] = arr[j + 1]
                        arr[j + 1] = temp
                    }
                }
            }
            console.log(arr);
        </script>
    </body>
    
    </html>
    

    从大到小排序

    <!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    </head>
    
    <body>
        <script>
            var arr = [324, 7378755, 5, 4, 54545, 5, 544, 13, 1, 5555555, 54, 5654, 556, 5, 2, 63, 949, 454635, 49, 6, 31, 2, 1, 164, 4554, 2, 21, 15]
            for (var i = 0; i < arr.length; i++) {
                45
                for (var j = 0; j < arr.length - i - 1; j++) {
                    if (arr[j] < arr[j + 1]) {
                        var temp = arr[j]
                        arr[j] = arr[j + 1]
                        arr[j + 1] = temp
                    }
                }
            }
            console.log(arr);
        </script>
    </body>
    
    </html>
    
    展开全文
  • // 从小到大顺序排序 minSort (arr) { var min for (var i = 0; i &lt; arr.length; i++) { for (var j = i; j &lt; arr.length; j++) { if (arr[i].coupon.faceMoney &gt; arr[j...

    从小到大:

    // 从小到大顺序排序
        minSort (arr) {
          var min
          for (var i = 0; i < arr.length; i++) {
            for (var j = i; j < arr.length; j++) {
              if (arr[i].coupon.faceMoney > arr[j].coupon.faceMoney) {
                min = arr[j]
                arr[j] = arr[i]
                arr[i] = min
              }
            }
          }
          return Arr
        }

    从大到小:

    getMaxSort: function (arr) {
          var max
          for (var i = 0; i < arr.length; i++) {
            for (var j = i; j < arr.length; j++) {
              if (arr[i].coupon.faceMoney < arr[j].coupon.faceMoney) {
                max = arr[j]
                arr[j] = arr[i]
                arr[i] = max
              }
            }
          }
          return arr
        }

    去重:

    Array.from(new Set(allNewgoodsList))
    
    原数组:【1,2,3,5,3,2】
    
    去重后:[1,2,3,5]

     

    展开全文
  • JS排序算法:冒泡法、快速排序法、选择排序法、插入排序法、哈希排序//生成数组 var arr = new Array(1000); for (var i = 0; i ; i++) { arr[i] = (Math.round(Math.random() * 1000)); }1.冒泡法 排序思想:...

    JS排序算法:冒泡法、快速排序法、选择排序法、插入排序法、哈希排序

    //生成数组
    var arr = new Array(1000);
    for (var i = 0; i < 1000; i++) {
        arr[i] = (Math.round(Math.random() * 1000));
    }

    1.冒泡法
    排序思想:数组相邻两项进行比较,如果前一项比后一项大则交换位置,比较arr.length-1轮,每一轮把最大的一位数放最后

    //冒泡法排序
    function sortArr(arr) {
        for (var i = 0; i < arr.length - 1; i++) {//比较arr.length-1轮
            for (var j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {//交换
                    var temp = arr[i];//临时变量
                    arr[i] = arr[j];
                    arr[j] = temp;
    
                }
            }
        }
        return arr;
    }

    2.快速排序法
    原理:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,
    整个排序过程可以递归进
    (1)在数据集之中,选择一个元素作为”基准”(pivot)。
    (2)所有小于”基准”的元素,都移到”基准”的左边;所有大于”基准”的元素,都移到”基准”的右边。
    (3)对”基准”左边和右边的两个子集,不断重复第一步和第二步,直到所有子集只剩下一个元素为止。
    快速排序的最坏运行情况是O(n²),比如说顺序数列的快排。但它的平摊期望时间是O(n log n) ,且O(n log n)记号中隐含的常数因子很小,比复杂度稳定等于O(n log n)的归并排序要小很多。所以,对绝大多数顺序性较弱的随机数列而言,快速排序总是优于归并排序。

    //快速排序法
    function sortQuick(arr) {
        if (arr.length <= 1) {//递归结束判断条件
            return arr;
        } else {
            var index = Math.floor(arr.length / 2);//取最中间的那个元素
            var len = arr.splice(index, 1);
            var left = [];
            var right = [];
    
            for (var i = 0; i < arr.length; i++) {
                if (arr[i] < len) {
                    left.push(arr[i]);
                } else {
                    right.push(arr[i]);
                }
            }
            return sortQuick(left).concat(len, sortQuick(right));
        }
    
    }

    3.选择排序法
    原理:每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法
    假定数组每次比较范围内第一个元素最小min,和剩下的比较,如果比假定的这个元素小,则令min为这个元素,直到找到最小的,然后交换位置,每比较一次,
    就把最小的一位数找出来放数组最前面。

    //选择排序
    function sortSelect(arr) {
        for (var i = 0; i < arr.length; i++) {
            var min = arr[i];
            var index = i;
            for (var j = i + 1; j < arr.length; j++) {
                if (arr[j] < min) {
                    min = arr[j];
                    index = j;
                }
            }
            if (index != i) {
                var temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp;
            }
    
        }
    
    }

    4.插入排序法
    插入算法把要排序的数组分成两部分:第一部分包含了这个数组的所有元素,但将最后一个元素除外(让数组多一个空间才有插入的位置),
    而第二部分就只包含这一个元素(即待插入元素)。在第一部分排序完成后,再将这个最后元素插入到已排好序的第一部分中。

    //插入排序
    function sortInsert(arr) {
        for (var i = 0; i < arr.length - 1; i++) {
            var insert = arr[i + 1];
            var index = i+1;
            for(var j=i;j>=0;j--){
                if(insert > arr[j]){
                    arr[j+1] = arr[j];
                    index = j;
                }
            }
            arr[index] = insert;
        }
    
    }

    5.哈希排序
    原理:先将整个待排元素序列分割成若干个子序列(由相隔某个“增量”的元素组成的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序
    (增量足够小)时,再对全体元素进行一次直接插入排序。

    //哈希排序
    function sortShell(arr){
        var len = arr.length,
            temp,
            gap = 1;
        while(gap < len/3){
            gap = gap*3+1;
        }
        for(gap;gap>0;gap = Math.floor(gap/3)){
            for(var i=gap;i<len;i++){
                temp = arr[i];
                for(var j=i-gap;j>0&&arr[j]>temp;j-=gap){
                    arr[j+gap] = arr[j];
                }
                arr[j+gap] = temp;
            }
        }
        return arr;
    }
    
    展开全文
  • JavaScript中几种常见排序算法小结,学习js的朋友可以参考下,下面对多种方法进行了简单的结。
  • 主要介绍了js交换排序 冒泡排序算法Javascript版) ,需要的朋友可以参考下
  • js 数组从大到小排序方法

    千次阅读 2020-04-16 13:03:37
    sort() 方法用于对数组的元素进行排序。 返回值 对数组的引用。请注意,数组在原数组上进行排序,不生成副本。 let roundList = [5,1,2,10,9] letnewArry=roundList.sort(function(a,b){ returnb-a; }); ...

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

    返回值

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

    let roundList = [5,1,2,10,9]
    let newArry = roundList.sort(function(a, b) {
    
          return b - a;
     });

    说明

    如果调用该方法时没有使用参数,将按字母顺序对数组中的元素进行排序,说得更精确点,是按照字符编码的顺序进行排序。要实现这一点,首先应把数组的元素都转换成字符串(如有必要),以便进行比较。

    如果想按照其他标准进行排序,就需要提供比较函数,该函数要比较两个值,然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b,其返回值如下:

    • 若 a 小于 b,在排序后的数组中 a 应该出现在 b 之前,则返回一个小于 0 的值。
    • 若 a 等于 b,则返回 0。
    • 若 a 大于 b,则返回一个大于 0 的值。
    展开全文
  • js实现10大排序算法

    万次阅读 2020-12-09 15:04:48
    冒泡排序 稳定 o(n^2) 原理: 相邻交换,每轮交换将当前最大放在队尾,下次循环长度-1 function bubbleSort(arr){ for(var i = 0; i<arr.length-1; i++){ for(var j = 0; j<arr.length-i-1; j++){ if(arr...
  • 冒泡排序算法 冒泡排序(Bubble Sort)是一种简单直观的排序算法。冒泡排序算法的步骤描述如下: 比较相邻的元素。如果第一个比第二个,就交换他们两个。对每一对相邻元素作同样的工作,开始第一对结尾...
  • JS排序算法

    2018-12-29 14:41:24
    JS排序算法
  • 主要介绍了JS排序算法之希尔排序与快速排序实现方法,结合实例形式分析了希尔排序与快速排序的原理及javascript实现技巧,需要的朋友可以参考下
  • 冒泡排序作为排序算法家族中的成员来说,相当于编程语言学习中的"Hello World",因为它是最简单的排序算法。冒泡排序会重复走访待排序序列,每次会比较序列中的相邻两个元素,如果这两个元素的顺序错误,就将它俩...
  • js排序算法JavaScript 中实现流行的排序算法 快速排序 归并排序 冒泡排序 插入排序
  • 主要为大家详细介绍了JavaScript希尔排序、快速排序、归并排序算法,感兴趣的朋友可以参考一下
  • JS 排序算法

    2017-03-31 16:28:50
    js排序算法,冒泡排序,插入排序,选择排序,希尔排序
  • 主要介绍了JS排序算法之冒泡排序,选择排序与插入排序,结合实例形式分析了冒泡排序,选择排序与插入排序的概念、原理及实现方法,需要的朋友可以参考下
  • js排序算法动态展示

    2019-03-18 17:39:07
    js排序算法动态显示js排序算法动态显示js排序算法动态显示js排序算法动态显示js排序算法动态显示js排序算法动态显示js排序算法动态显示js排序算法动态显示js排序算法动态显示js排序算法动态显示js排序算法动态显示js...
  • 原理:临近的数字两两进行比较,按照从小到大或者大到的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束 时间复杂度:平均情况:O(n2)...
  • 这个算法的名字由来是因为越的元素会经由交换慢慢“浮”数列的顶端。 作为最简单的排序算法之一,冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样,每次都在第一页第一位,所以最熟悉。冒泡排序还有一...
  • 快速排序也许是最常用的排序算法了。它的复杂度为O(nlogn),且它的性能通常比其他的复杂度为O(nlogn)的排序算法要好。和归并排序一样,快速排序也使用分治的方法,将原始数组分为较的数组(但它没有像归并排序那样...
  • 插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即...
  • javascript 10大排序算法

    2019-03-04 17:29:50
    排序算法说明: (1)对于评述算法优劣术语的说明 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面; 内排序:所有排序操作都在内存中...
  • JavaScript实现排序算法

    2018-01-04 19:57:47
    下面的排序算法都假设是从小到大进行排序,大到可以相应进行转化。 冒泡排序 冒泡排序的基本思想是从头遍历要排序的数组,比较相邻两个数,如果前面位置的数大于后面位置的数,那么就将两者进行交换,否则不做...
  • javascript数据结构与算法--高级排序算法(快速排序法,希尔排序法) 一、快速排序算法 /* * 这个函数首先检查数组的长度是否为0。如果是,那么这个数组就不需要任何排序,函数直接返回。 * 否则,创建两个...
  • JavaScript排序算法(希尔排序,快速排序)希尔排序执行顺序代码实现快速排序执行顺序代码实现 希尔排序 执行顺序 图示 执行顺序 步长取 step = step / 2; 默认步长 step = length / 2;在一个分组内采用插入排序...
  • 主要介绍了JS实现的冒泡排序,快速排序,插入排序算法,结合实例形式分析了javascript冒泡排序,快速排序,插入排序算法的相关原理及实现方法,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 75,422
精华内容 30,168
关键字:

js从大到小排序算法