×

js数组排序 or 数组

js数组排序（JS数组sort方法如何使用）

admin admin 发表于2022-09-04 20:27:46 浏览140 评论0

抢沙发发表评论

本文目录

JS数组sort方法如何使用


定义和用法：
sort() 方法用于对数组的元素进行排序。
语法：
1
arrayObject.sort(sortby)
描述：
sortby 可选。规定排序顺序。必须是函数。
返回值：
对数组的引用。请注意，数组在原数组上进行排序，不生成副本。
说明：
如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较。
如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：
若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
若 a 等于 b，则返回 0。
若 a 大于 b，则返回一个大于 0 的值。

js中数组排序的方法


//排序算法
window.onload = function(){
    var array = [0,1,2,44,4,
                324,5,65,6,6,
                34,4,5,6,2,
                43,5,6,62,43,
                5,1,4,51,56,
                76,7,7,2,1,
                45,4,6,7,8];
    //var array = [4,2,5,1,0,3];
    array = sorting.shellSort(array);
    alert(array);
}
var sorting = {
    //利用sort方法进行排序
    systemSort: function(arr){
        return arr.sort(function(a,b){
            return a-b;
        });
    },
    //冒泡排序
    bubbleSort: function(arr){
        var len=arr.length, tmp;
        for(var i=0;i《len-1;i++){
            for(var j=0;j《len-1-i;j++){
                if(arr[j]》arr[j+1]){
                    tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        return arr;
    },
    //快速排序
    quickSort: function(arr){
        var low=0, high=arr.length-1;
        sort(low,high);
        function sort(low, high){
            if(low《high){
                var mid = (function(low, high){
                    var tmp = arr[low];
                    while(low《high){
                        while(low《high&&arr[high]》=tmp){
                            high--;
                        }
                        arr[low] = arr[high];
                        while(low《high&&arr[low]《=tmp){
                            low++;
                        }
                        arr[high] = arr[low];
                    }
                    arr[low] = tmp;
                    return low;
                })(low, high);
                sort(low, mid-1);
                sort(mid+1,high);
            }
        }
        return arr;
    },
    //插入排序
    insertSort: function(arr){
        var len = arr.length;
        for(var i=1;i《len;i++){
            var tmp = arr[i];
            for(var j=i-1;j》=0;j--){
                if(tmp《arr[j]){
                    arr[j+1] = arr[j];
                }else{
                    arr[j+1] = tmp;
                    break;
                }
            }
        }
        return arr;
    },
    //希尔排序
    shellSort: function(arr){
        console.log(arr);
        var h = 1;
        while(h《=arr.length/3){
            h = h*3+1;  //O(n^(3/2))by Knuth,1973
        }
        for( ;h》=1;h=Math.floor(h/3)){
            for(var k=0;k《h;k++){
                for(var i=h+k;i《arr.length;i+=h){
                    for(var j=i;j》=h&&arr[j]《arr[j-h];j-=h){
                        var tmp = arr[j];
                        arr[j] = arr[j-h];
                        arr[j-h] = tmp;
                    }
                }
            }
        }
        return arr;
    }
}

JavaScript数字数组怎么按数字大小排序


  1. 先写上我们的示例代码，定义了一个数组arr，数组包括有几个字母，不按顺序的，要对数组进行排序，直接调用sort方法。再加上一些输出语句，console.log是指在浏览器的调试控制台里输出内容。

  2. 运行页面，我们在控制台里看下结果，如图，数组调用sort方法后，就按字母的升序做好排序了。

  3. 修改下代码，把数组内容从字符串改成数字，然后再调用sort方法。

  4. 修改后，运行页面，再看下结果。

  5. 数组排序都是按字符串来排序的，而不管数组内容是数字还是字符串。

  6. 修改下sort排序方法，把刚才定义的方法名传进来。

  7. 运行页面，可以看到现在的数组就是按数字从小到大排序的。

好，Javascript中的数字数组排序非常简单，JS本身提供了内置的排序方法，直接调用就可以了。

1.var arr = [1, 20, 49, 32, 43, 69];

2.arr.sort();

3.console.log(arr); // [1, 20, 32, 43, 49, 69]


javascript对数组的排序


其实这个函数只是一个形式，如果定义成这样：
function sortNumber(b,a){
return b-a;
}
排序出来也是升序的。其与
function sorNumber(a,b){
return a-b;
}
的效果是一样的。
也就是说对于这个传入的函数，如果返回用第一个参数减去第二个参数，那么是升序排列；
如果返回用第二个参数减去第一个参数，那么是降序排列。
如果不传入函数，那么是按照字符串的字典顺序升序排列。
-数组

JS数组排序


// 对数组排序，并将值为val的放在最前
function sortArray(arr, val){
    // 数组排序
    arr.sort(function(e1, e2){
        if(e2 == val){
            return 1;
        }
        if(e1 == val){
            return -1;
        }    
        return e1 - e2;
    });
    
    // 修改序号
    for(var i = 0; i 《 arr.length; i++){
        arr[i] = i + 1;
    }
}
// 声明数组
var arr = [[1, 1, ’a’],[2, 2, ’b’],[3, 4, ’c’],[4, 2, ’d’],[5, 5, ’e’]];
// 调用排序
sortArray(arr, 2);
// 在控制台查看排序结果
console.log(arr);
-or

JS中数组重排序方法


1.数组中已存在两个可直接用来重排序的方法：reverse（）和sort（）。
reverse()和sort（）方法的返回值是经过排序后的数组。reverse（）方法会反转数组项的顺序：
var
values=[1,2,3,4,5];
values.reverse();
alert(values);
//5,4,3,2,1
在默认情况下，sort（）方法按升序排列数组，sort（）方法会调用每个数组项的toString（）转型方法，然后比较得到字符串，确定如何排序。即使数组中的每一项都是数值，sort（）方法比较的也是字符串：
var
values
=
[0,1,5,10,15];
values.sort();
alert(values);
//0,1,10,15,5
因此，sort（）方法可以接收一个比较函数作为参数。
function
compare(value1,value2){
if
(value1
《
value2){
return
-1;
}else
if
(value1
》
value2){
return
1;
}else{
return
0;
}
}
此比较函数可适用于大多数数据类型，只要将其作为参数传递给sort（）方法即可：
var
values
=
[0,1,3,7,9,15];
values.sort(compare);
alert(values);
//0,1,3,7,9,15
也可通过比较函数产生降序排序，只需交换函数返回值即可：
function
compare
(value1,
value2){
if
(value1《value2){
return
1;
}else
if
{
return
-1;
}else{
return
0;
}
}
sort()函数的排序条件是：
参数大于0，arr的相邻两个元素交换位置;
参数小于0，arr的相邻两个元素不交换位置;
参数等于0，arr的相邻两个元素大小相等;所以compare自定义函数必须返回一个数值。
2.对于数值类型或者valueOf（）方法会返回数值类型的对象类型。
可使用一个更简单的比较函数。此函数只要第二个值减第一个值即可。
function
compare
(value1,value2){
return
value2
-
value1;
}
以上所述是小编给大家介绍的JS中数组重排序方法，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的支持！
-数组

JavaScript数字数组怎么按数子大小排序


你好，Javascript中的数字数组排序非常简单，JS本身提供了内置的排序方法，直接调用就可以了。

var arr = [1, 20, 49, 32, 43, 69];
arr.sort();
console.log(arr); // [1, 20, 32, 43, 49, 69]

还有一种更加灵活的写法：-or

arr.sort(function(a, b){
    return a - b;
});
console.log(arr); // [1, 20, 32, 43, 49, 69]

如果想倒序也很简单，交换下return中a、b的位置就可以了：-数组

arr.sort(function(a, b){
    return b - a;
});
console.log(arr); // [69, 49, 43, 32, 20, 1]

好了，就这样。希望是你想要的答案，望采纳，如有疑问请追问！-or


如何用JS做数组排序


var arr =  [“4_jpg“,“2_jpg“,“3_jpg“ ,“1_jpg“,“6_jpg“, “5_jpg“];
arr.sort(function(a,b){
    return a.localeCompare(b);
});
console.log(arr);
-数组

JS实现数组排序的方法有哪些


从给定的数据中，随机抽出一项，这项的左边放所有比它小的，右边放比它大的，然后再分别这两边执行上述操作，采用的是递归的思想，总结出来就是　实现一层，分别给两边递归，设置好出口

function fastSort(array,head,tail){
    //考虑到给每个分区操作的时候都是在原有的数组中进行操作的，所以这里head,tail来确定分片的位置
    /*生成随机项*/
    var randomnum = Math.floor(ranDom(head,tail));
    var random = array[randomnum];
    /*将小于random的项放置在其左边  策略就是通过一个临时的数组来储存分好区的结果，再到原数组中替换*/
    var arrayTemp = ;
    var unshiftHead = 0;
    for(var i = head;i 《= tail;i++){
      if(array[i]《random){
        arrayTemp.unshift(array[i]);
        unshiftHead++;
      }else if(array[i]》random){
        arrayTemp.push(array[i]);
      }
      /*当它等于的时候放哪，这里我想选择放到队列的前面，也就是从unshift后的第一个位置放置*/
      if(array[i]===random){
        arrayTemp.splice(unshiftHead,0,array[i]);
      }
    }
    /*将对应项覆盖原来的记录*/
    for(var j = head , u=0;j 《= tail;j++,u++){
      array.splice(j,1,arrayTemp[u]);
    }
    /*寻找中间项所在的index*/
    var nowIndex = array.indexOf(random);
    /*设置出口，当要放进去的片段只有2项的时候就可以收工了*/
    if(arrayTemp.length 《= 2){
      return;
    }
    /*递归，同时应用其左右两个区域*/
    fastSort(array,head,nowIndex);
    fastSort(array,nowIndex+1,tail);
  }

JavaScript实现多维数组、对象数组排序，其实用的就是原生的sort()方法，用于对数组的元素进行排序。-or

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

arrayObject.sort(sortby)
例如：
function NumAscSort(a,b)
{
 return a - b;
}
function NumDescSort(a,b)
{
 return b - a;
}
var arr = new Array( 3600, 5010, 10100, 801); 
arr.sort(NumDescSort);
alert(arr);
arr.sort(NumAscSort);
alert(arr);
-数组

JS中数组如何重新排序


数组排序，你可以直接调用javascript原生自带的sort()方法，比如下面的例子：
// Array.prototype.sort()   //原生自带的数组的排序方法；
var fruit = [’apples’, ’bananas’, ’Cherries’];   //定义一个数组
fruit.sort(); // [’Cherries’, ’apples’, ’bananas’];  //按字母排序的结果
var scores = [1, 2, 10, 21];   //定义一个数字排序，你发现其实还是按照字母序排列的
scores.sort(); // [1, 10, 2, 21]
如果希望按照期望的数字排序。
scores.sort(function(a,b){return a-b}); //这样的就可以了。结果为：21 10 2 1 
var things = [’word’, ’Word’, ’1 Word’, ’2 Words’];
things.sort(); // [’1 Word’, ’2 Words’, ’Word’, ’word’]
// In Unicode, numbers come before upper case letters,
// which come before lower case letters.
-or