谁能告诉我为什么这个JavaScript代码没有按顺序排列一个数组？

Question

实时代码： http ： //jsfiddle.net/fCUZC/

//INPUT ARRAY:
var input = [28,32,21,11,8,2,14,32,64];
//VARIABLE DECLARATION. a = highest number so far, b = position of that number
entireLoop:
for (var i = 1; i<=input.length; i++)
{
    if(input[i] > input[i-1])
    {
        for(var o = i; o>=0; o--)
        {
            if(input[i-1] > input[o])
            {
                input.splice(i,0,input[o]);
                input.splice((o+1),1);
                continue entireLoop;
            }
            else if(input[o] > input[0])
            {
                input.splice(0,0,input[o]);
                input.splice((o+1),1);
                continue entireLoop;
            }

        }
    }
}
document.write(input);

我正在尝试从最大到最小排序数组，但是某个地方有32个数组。 我知道有排序方法，但是我是新手，想亲自尝试一下。

Answer 1

**编辑**首先看一下数组的本机.sort（）方法。 它保持原始数组不变，并接受比较函数。 后者使.sort（）变得非常强大。

var input = [28,32,21,11,8,2,14,32,64];

var low2high = function ( a , b ) {
    return a > b;
};

var high2low = function ( a , b ) {
    return a < b;
};

var resultHigh2low = input.sort( high2low ); // [ 64,32,32,28,21,14,11,8,2 ];
var resultLow2high = input.sort( low2high ); // [ 2,8,11,14,21,28,32,32,64 ];

因此，如果我们要使用bubbleSort（TJ Crowder提供的链接，请参阅OP注释），我们可以编写以下内容：

// javascript bubbleSort implementation
var bubbleSort = function ( list , comparison ) {
    var swapped;
    var i;
    var val;

    list = [].concat( list ); // do not destroy original
    comparison = ( typeof comparison == "function" ) ? comparison : function(a,b){return a > b;}

    do {
        i = list.length;
        while ( --i ) {
           if ( i && comparison( list[ i ] , comparison[ i-1] ) ) {
                val = list[ i ];
                list[ i ] = list[ i - 1 ];
                list[ i - 1] = val;
                swapped = true;
           }
        }
    } while ( swapped );
    return list;
}

// using comparison functions from previous example.
var resultHigh2low = bubbleSort( input , high2low ); // [ 64,32,32,28,21,14,11,8,2 ];
var resultLow2high = bubbleSort( input , low2high ); // [ 2,8,11,14,21,28,32,32,64 ];

让我们逐步介绍它：

var bubbleSort = function ( list , comparison ) {
    ..code..
}

我们的函数接受2个参数，第一个是数组，第二个是可选的比较函数。

var swapped;
var i = list.length;
var val;

我们将列表的长度存储在变量i ，并声明2个空变量（ swapped和val ），稍后我们将使用它们。

list = [].concat( list ); // do not destroy original

我们使用[].concat( array )克隆列表，并覆盖本地list变量，而保持原始状态不变。

comparison = ( typeof comparison == "function" ) ? comparison : function(a,b){return a > b;}

我们测试typeof的comparison论证，如果它是一个function ，我们使用的是一个，否则我们依傍我们自己的comparison功能。 如果a大于b我们的后备比较函数将返回true 。

do {
    ..code..
} while ( swapped );

do / while循环将至少运行一次，我们的swapped变量当前undefined因此将被解释为虚假。 如果我们的comparison函数返回true，则会发生交换，并且swapped变量将被设置为true，因此它将再次循环。

while ( --i ) {
    ..code..
}

在这里，我从列表的长度开始向下循环，将--运算符放在i变量之前，以确保首先在任何变量之前对其进行处理；由于list[ list.length ]不存在，因此while评估会导致错误的结果之后i--将关闭。 我总是这样做（可能是坏习惯），但是如果让您感到困惑，请绝对透明。

if ( i && comparison( list[ i ] , comparison[ i-1] ) ) {
    ..code..
}

首先，我们检查i是否具有真实值（0等于falsy），然后运行comparison函数，将list[ i ]和list[ i - 1 ]作为a和b参数传递。 如果comparison函数返回true ，则执行交换。

val = list[ i ];
list[ i ] = list[ i - 1 ];
list[ i - 1] = val;
swapped = true;

在这里，我不使用.splice()方法执行交换，这只是有根据的猜测atm。但是我认为直接分配比函数调用要快。 我使用val变量作为占位符。 交换完成后，我将swapped设置为true，这样我们的do / while循环将继续。

return list;

好吧...返回结果。

我已经排除了一些检查，例如当列表的长度为0时我们做什么。 基本上，在编写辅助函数时，我们还需要处理错误处理。 例如，当传递的比较参数不是函数时引发TypeError，例如，确保比较方法返回布尔值，依此类推。

Answer 2

//INPUT ARRAY:
var input = [28,32,21,11,8,2,14,32,64];
//VARIABLE DECLARATION. a = highest number so far, b = position of that number
for (var i = 1; i<input.length; i++)
{
    if(input[i] > input[i-1])
    {
        for(var o = i-1; o>=0; o--)
        {
            if(input[i] > input[o])
            {
                input.splice(i+1,0,input[o]);
                input.splice((o),1);
                i--;
            }       
        }
    }
}
document.write(input);

虽然它仍然不是很好，但它应该可以工作。 请记住，我几乎没有对此进行测试，并且对JavaScript缺乏经验。 您的意图并不都是坏事，每个人都需要从某个地方开始。

最大的问题仅仅是内部条件。 我可以看到您的逻辑，即从找到的较大值向后循环，然后将所有较小的值向右推。 不幸的是，您的索引有些不足。 您还需要运行此循环，直到它正常结束为止，而不是继续进行，否则，您将只切换一个值。 固定此条件后，不再需要第二个条件

另一种形式是从最低的索引开始，然后找到小于input [i]的第一个值，然后将其放在那里。 这可能更清楚。

我认为这是一个很好的第一枪，并且开始工作并不难。 祝好运！