如何根据每个元素的长度对数组进行排序？

小开

最佳答案

可以使用 Array.sort方法对数组进行排序。将字符串长度作为排序条件的排序函数可以使用如下方式:

arr.sort(function(a, b){
// ASC  -> a.length - b.length
// DESC -> b.length - a.length
return b.length - a.length;
});

注意: 按字符串长度排序 ["a", "b", "c"]并不保证返回 ["a", "b", "c"]。根据说明书:

排序不一定是稳定的(即比较的元素) 不一定保持原来的顺序)。

如果目标是按长度排序，那么必须按字典顺序指定其他条件:

["c", "a", "b"].sort(function(a, b) {
return a.length - b.length || // sort by length, if equal then
a.localeCompare(b);    // sort by dictionary order
});

小开

下面是按照您的要求使用 < strong > Bubble sort 的 javascript 根据字符串的长度进行排序:

var arr = ['1234', '12', '12345', '1'];


bubbleSort(arr );


function bubbleSort(a) {
var swapped;
do {
swapped = false;
for (var i = 0; i < a.length - 1; i++) {
if (a[i].length < a[i + 1].length) {
var temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
swapped = true;
}
}
} while (swapped);
}


console.log(arr );

小开

<script>
arr = []
arr[0] = "ab"
arr[1] = "abcdefgh"
arr[2] = "sdfds"
arr.sort(function(a,b){
return a.length<b.length
})
document.write(arr)


</script>

传递给 sort 的匿名函数告诉它如何对给定的 array.hope 进行排序。我知道这有点让人困惑，但是你可以通过传递一个函数作为参数告诉 sort 函数如何对数组的元素进行排序

小开

根据 Salman 的回答，我编写了一个小函数来封装它:

function sortArrayByLength(arr, ascYN) {
arr.sort(function (a, b) {           // sort array by length of text
if (ascYN) return a.length - b.length;              // ASC -> a - b
else return b.length - a.length;                    // DESC -> b - a
});
}

那就用

sortArrayByLength( myArray, true );

请注意，遗憾的是，函数不能/不应该被添加到 Array 原型中，正如在这一页中所解释的那样。

此外，它修改了作为参数传递的数组，并且不返回任何内容。这会强制复制数组，对于大型数组来说不是很好。如果有人有更好的主意，请评论！

小开

我改编了@Shareef 的回答，使其简洁明了,

.sort(function(arg1, arg2) { return arg1.length - arg2.length })

小开

我们可以使用 一个 href = “ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global _ Objects/Array.sort”rel = “ norefrer”> Array.sort 方法对这个数组进行排序。

ES5解决方案

var array = ["ab", "abcdefgh", "abcd"];


array.sort(function(a, b){return b.length - a.length});


console.log(JSON.stringify(array, null, '\t'));

对于上升排序顺序: a.length - b.length

对于 descending排序顺序: b.length - a.length

ES6解决方案

注意: 不是所有的浏览器都能理解 ES6代码！

在 ES6中我们可以使用 < a href = “ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/function/Arrow _ function”rel = “ noReferrer”> 箭头函数表达式 。

let array = ["ab", "abcdefgh", "abcd"];


array.sort((a, b) => b.length - a.length);


console.log(JSON.stringify(array, null, '\t'));

小开

这段代码应该可以解决这个问题:

var array = ["ab", "abcdefgh", "abcd"];


array.sort(function(a, b){return b.length - a.length});


console.log(JSON.stringify(array, null, '\t'));

小开

#created a sorting function to sort by length of elements of list
def sort_len(a):
num = len(a)
d = {}
i = 0
while i<num:
d[i] = len(a[i])
i += 1
b = list(d.values())
b.sort()
c = []
for i in b:
for j in range(num):
if j in list(d.keys()):
if d[j] == i:
c.append(a[j])
d.pop(j)
return c

小开

如果希望保留与原始数组长度相同的元素的顺序，请使用气泡排序。

Input = ["ab","cdc","abcd","de"];


Output  = ["ab","cd","cdc","abcd"]

Function:

function bubbleSort(strArray){
const arrayLength = Object.keys(strArray).length;
var swapp;
var newLen = arrayLength-1;
var sortedStrArrByLenght=strArray;
do {
swapp = false;
for (var i=0; i < newLen; i++)
{
if (sortedStrArrByLenght[i].length > sortedStrArrByLenght[i+1].length)
{
var temp = sortedStrArrByLenght[i];
sortedStrArrByLenght[i] = sortedStrArrByLenght[i+1];
sortedStrArrByLenght[i+1] = temp;
swapp = true;
}
}
newLen--;
} while (swap);
return sortedStrArrByLenght;
}

小开

let array = [`ab`, `abcdefgh`, `abcd`];
let newArray = array.sort((a,b) => {
return b.length - a.length
})
console.log(newArray);

请输入以下代码

小开

使用现代的 JavaScript，你可以这样做:

Descending order

const arr = [
"ab",
"abcdefgh",
"abcd",
"abcdefghijklm"
];


arr.sort((a, b) => b.length - a.length);


console.log(JSON.stringify(arr, null, 2));

升序 -只需将 a与 b切换

const arr = [
"ab",
"abcdefgh",
"abcd",
"abcdefghijklm"
];


arr.sort((a, b) => a.length - b.length);


console.log(JSON.stringify(arr, null, 2));

小开

let arr  = [5,2,100,1,20,3];
arr.sort((a,b)=>{
return a-b
})


console.log(arr) //[1, 2, 3, 5, 20, 100]

在返回值上，sort 方法将执行元素交换的功能

return < 0  { i.e -ve number then  a comes before b}
return > 0  { i.e +ve number then  b comes before a}
return == 0 { order of a and b remains same }