如何對數組進行排序以使最大值位於中間？

Question

假設我有一個簡單的數組：

[1, 20, 15, 37, 46, 9]

我需要讓它看起來像這樣：

[1, 9, 15, 46, 37, 20]

因此，我們的想法是將最大的值或最大的兩個值中的一對放在數組的中間，然后像金字塔一樣將遞減的數字放在數組的右側和左側。

我有一些想法，但它們似乎不夠優雅。 請指教。

Answer 1

嘗試這個：

var arr = [1, 20, 15, 37, 46, 9];
arr.sort(function (a, b) {
    return a - b;
});
var arr1 = arr.slice(0, arr.length / 2);
var arr2 = arr.slice(arr.length / 2, arr.length);
arr2.sort(function (a, b) {
    return b - a;
});
arr = arr1.concat(arr2);
console.log(arr);

這個方法恢復到兩個步驟：

[1, 20, 15, 37, 46, 9]    // step 1: sort the entire array
[1, 9, 15, 20, 37, 46]    // step 2: sort the second half of the array
[1, 9, 15, 46, 37, 20]

Answer 2

var arr = [1,20,15,37,46,9];
arr.sort(function(a,b){
 return a-b;
});
var right = arr.slice(arr.length/2,arr.length).reverse();
var left = arr.slice(0,arr.length/2);
arr = left.concat(right);
console.log(arr);

Answer 3

這可以優化，但它有效。

function pyramid (arr) {
    var newArr = [];

    // sort numerically
    arr.sort(function (a, b) {
        return a - b;
    });

    // put the biggest in new array
    newArr.push(arr.pop());

    // keep grabbing the biggest remaining item and alternate
    // between pushing and unshifting onto the new array
    while (arr.length) {
        newArr[arr.length % 2 === 0 ? 'push' : 'unshift'](arr.pop());
    }

    return newArr;
}

pyramid([1, 20, 15, 37, 46, 9]返回[1, 15, 37, 46, 20, 9]

Answer 4

我不能給你一個 javascript 例子，但我會先把每個數組元素按順序排列，然后枚舉（給出一個索引），然后從前面和后面以偶數/奇數順序添加它們。

[1, 20, 15, 37, 46, 9]

變成

[1, 9, 15, 20, 37, 46]

然后打印最多為數組大小一半的奇數索引，然后從末尾打印偶數索引回到一半。

編輯： python 好玩：

tt = sorted([1, 20, 15, 37, 46, 9])
print tt[0:len(tt)/2] + list(reversed(tt[len(tt)/2:len(tt)]))

Answer 5

這是另一種短鏈方法：

[1, 20, 15, 37, 46, 9].sort(function(a, b) {
    return a - b;
}).map(function(v, i, a) {
    var p = ~~(a.length / 2);
    return i >= p ? a[a.length - i + p - 1] : v;
});

// [1, 9, 15, 46, 37, 20]

似乎可以很好地處理數組中的任意數量的元素。

Answer 6

當您有更多元素時，對數組進行排序、將其減半，然后將它們拼接在一起的技術效果不佳。 一側比另一側“大”。

let arr = [361, 324, 289, 256, 225, 196, 169, 144, 121, 100, 81, 64, 49, 36, 25, 16, 9, 4, 1, 0];
arr = arr.slice(arr.length/2).reverse().concat(arr.slice(0,arr.length/2));
// [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 361, 324, 289, 256, 225, 196, 169, 144, 121, 100]

交錯奇偶索引看起來更好，而且只需要稍微長一點

arr = arr.filter((v, i)=>i % 2 === 0).reverse().concat(arr.filter((v, i)=>i % 2 === 1));
// [1, 9, 25, 49, 81, 121, 169, 225, 289, 361, 324, 256, 196, 144, 100, 64, 36, 16, 4, 0]

Answer 7

更簡單的算法

首先- 按降序排列數組並定義一個新的空數組。

其次- 遍歷已排序的數組並按以下方式插入其項目 -如果甚至推送到空數組，否則取消移動該項目。

例子

let randoms = [7 ,53 ,21, 43 ,45 ,8, 12, 9, 3, 22, 21]; //some random unsorted array

randoms.sort((a,b) => b - a);   // sorting the array
let sortedFromMiddle = []; //the new empty array

randoms.forEach(( num, index ) => { 
    index % 2 === 0 ? sortedFromMiddle.push(num) : sortedFromMiddle.unshift(num);
  });

console.log(sortedFromMiddle); // will log the array 

Answer 8

拼接的返回是從原始元素中刪除的一組項目 -

function pyramid(arr){
    var  mid= Math.floor(arr.length/2);
    var a2= arr.sort(function(a,b){return a-b}).splice(mid);
    return arr.concat(a2.reverse());
}

var a1= [1, 20, 15, 37, 46, 9];
pyramid(a1)

/* 返回值：（數組）1,9,15,46,37,20 */

Answer 9

var data = [1, 20, 15, 37, 46, 9];
arr = data.sort(function(a, b){return a - b});
console.log(arr);

這將返回您[1, 9, 15, 20, 37, 46]