Question

Live code: 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);

I’m trying to order the array from largest to smallest, but there’s a 32 stuck somewhere. I know there’s the sort method, but I’m a newbie and want to try this for myself.

Answer 1

** edit **
First have a look at the Array’s native .sort() method. It leaves the original array intact and accepts a comparison function. The latter makes .sort() pretty powerful.

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 ];

So if we want to use bubbleSort ( link provided by T.J. Crowder , see OP comments ) we can write the following:

// 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 ];

Lets walk through it step by step:

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

Our function accepts 2 parameters, first the array and 2nd an optional comparison function.

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

We store the list’s length under variable i, and declare 2 empty variables ( swapped and val ) we’re going to use later on.

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

We clone the list using [].concat( array ) and overwrite the local list variable leaving the original intact.

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

We test the typeof the comparison argument, if it’s a function we use that one, otherwise we fall back on our own comparison function. Our fallback comparison function will return true if a is bigger than b.

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

A do/while loop will run at least once, our swapped variable is currently undefined so it will be interpreted as falsy. If our comparison function returns true, a swap occurs and the swapped variable will be set to true, so it will loop again.

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

Here I loop from the list’s length downward, the -- operator is put before the i variable to ensure it is handled first before anything, i-- would go off after while evaluation causing erronous results since list[ list.length ] does not exist. I always do it this way (bad habbit perhaps), but if it confuses you, go for absolute transparancy.

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

First we check if i has a truthy value ( 0 evaluates to falsy ) and then we run the comparison function passing list[ i ] and list[ i - 1 ] as a and b parameters. If the comparison function returns true, we perform a swap.

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

Here I perform the swap without using the .splice() method, it’s just an educated guess atm., but I figure direct assignments are faster then function calls. I use the val variable as a place holder. After the swap is done, I set swapped to true so our do/while loop will continue.

return list;

Well… return the result.

I’ve excluded some checks, like what do we do when the list’s length is 0 and whatnot. Basically when writing helper functions, we also need to deal with error handling. Like for example throwing a TypeError when the passed comparison argument is not a function, ensuring the comparison method returns a boolean value and so on.