Javascript 生成以下结果的更好算法是什么？

我们有一个具有

n

数字（非零）的数组输入，即

现在我们希望输出为

output--> Ai <= Aj >= Ak <= Al >= Am <= ....An.

---

output-->Ai=Ak=Am当前算法在
O（n log n）
时间上运行。开始时的
.sort（）
需要
O（n log n）
时间，而下面的
for
循环在
O（n）
时间内运行。因此，一个可能的改进是将
sort
函数改为使用计数排序（它具有时间复杂性
O（n+k）
，其中
k
是从最低数字到最高数字的范围）。这将使总体时间复杂度从
O（n logn）
降低到
O（n+k）
，这对于较大的集合将是一个显著的改进：


函数计数排序（数组）{
常量计数=数组。减少（（a，num）=>{
a[num]=（a[num]| | 0）+1；
返回a；
}, {});
/*
好吧，也许这是作弊
返回Object.entries（counts）.reduce（（arr，[num，出现次数]）=>{
for（设i=0；i<出现次数；i++）{
arr.push（数（num））；
}
返回arr；
}, []);
*/
常量排序=[]；
const min=Math.min（…数组）；
const max=Math.max（…数组）；
对于（设i=min；i您不需要对数组进行排序。
只需对数组进行一次遍历，并且在每个步骤中只修复一个[i]，一个[i+1]

假设a[1]=a[3]…=a[i]

现在，如果a[i]a[i+1]，交换它们

对称地，当i为偶数时，如果a[i]这最终可能是一个更好的逻辑：-

    function optimizedSort(array) {
    if(array && array.length){
        let temp;
        for(let i=0;i<array.length;i++){
            if((i+1)%2){
                // i is odd

                if(array[i]>=array[i+1]){
                    temp = array[i];
                    array[i] = array[i+1];
                    array[i+1] = temp;
                }

            }else{
                // i is even

                if(array[i]<=array[i+1]){
                    temp = array[i];
                    array[i] = array[i+1];
                    array[i+1] = temp;
                }
            }
        }
        console.log('********',array);
        return array;
    }else{
        throw 'invalid argument';
    }
}
optimizedSort([1,2,3,4]);

函数优化排序（数组）{
if（array&&array.length）{
让温度；
for（设i=0；i=array[i+1]）{
温度=阵列[i]；
数组[i]=数组[i+1]；
阵列[i+1]=温度；
}
}否则{
//我甚至
如果（array[i]你能用语言解释一下你想做什么吗？还不完全清楚，我不确定什么是
Ai=Ak=Am-nope，这是错误的！请检查以下内容：ip:1,6,2,8,10，3@ReturnZero{1,6,2,8,10,3}->{1,6,2,10,8,3}->{1,6,2,10,3,8}谢谢，这是一个很好的解决方案。@shukiavraham对称地说，当我是偶数时，如果a[i]function test(array){
    if(array && array.length){
        let newArray = [];
        array = array.sort();
        let m;
        if(array.length % 2){
            m = (array.length +1 )/2;
        }else{
            m = (array.length)/2;
        }
        newArray.push(array[m-1]);
        for(let i=1;i<=m;i++){
            if(array[m-1+i])
            newArray.push(array[m-1+i]);
            if(array[m-1-i])
            newArray.push(array[m-1-i]);
        }
        console.log(newArray);
        return newArray;
    }else{
        throw 'invalid argument';
    }
}

test([1,2,3,4]);

    function optimizedSort(array) {
    if(array && array.length){
        let temp;
        for(let i=0;i<array.length;i++){
            if((i+1)%2){
                // i is odd

                if(array[i]>=array[i+1]){
                    temp = array[i];
                    array[i] = array[i+1];
                    array[i+1] = temp;
                }

            }else{
                // i is even

                if(array[i]<=array[i+1]){
                    temp = array[i];
                    array[i] = array[i+1];
                    array[i+1] = temp;
                }
            }
        }
        console.log('********',array);
        return array;
    }else{
        throw 'invalid argument';
    }
}
optimizedSort([1,2,3,4]);