Bubble sort algorithm JavaScript [closed]

Question

Please can you tell me what is wrong to this implementation of bubble sort algorithm in JavaScript?

for (var i=1; i<records.length; i++){
        for (var j=records.length; j<1; j--){
            if (parseInt(records[i-1]) < parseInt(records[i])){
                var temp = records[i-1];
                records[i-1] = records[i]
                records[i] = temp;
            }   
        }    
    }

Answer 1

the second for loop is coded wrong it should be

for (var i=0; i<records.length; i++){
    for (var j=0; j<records.length; j++){
        if (parseInt(records[i]) > parseInt(records[j])){
            var temp = records[i];
            records[i] = records[j];
            records[j] = temp;
        }   
    }    
}

Answer 2

My solution:

  function bubbleSort(A){
  var swapped,
      len = arr.length;

  if(len === 1) return;

  do {
    swapped = false;
    for(var i=1;i<len;i++) {
      if(A[i-1] > A[i]) {   
        var b = A[i];
        A[i] = A[i-1];
        A[i-1] = b;
        swapped = true;
      }   
    }

  }
  while(swapped)  
}

var arr = [1, 6, 9, 5, 3, 4, 2, 12, 4567, 5, 34];
bubbleSort(arr);
document.write(arr);

Answer 3

for (var j=records.length; j<1; j--){

Shouldn't that be

for (var j=records.length; j>1; j--){

Answer 4

A simple implementation in ES6 JavaScript will be

    function BubbleSort(arr) {
      const sortedArray = Array.from(arr);
      let swap;
      do {
        swap = false;
        for (let i = 1; i < sortedArray.length; ++i) {
          if (sortedArray[i - 1] > sortedArray[i]) {
            [sortedArray[i], sortedArray[i - 1]] = [sortedArray[i - 1], sortedArray[i]];
            swap = true;
          }
        }
      } while (swap)
      return sortedArray;
    }
console.log(BubbleSort([3, 12, 9, 5]));

Answer 5

Couple of codes for bubble sort

bubblesort should not be used for larger arrays, can be used for smaller ones for its simplicity.

Method 1

var a = [33, 103, 3, 726, 200, 984, 198, 764, 9];

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

bubbleSort(a);
console.log(a);

Method 2

function bubbleSort(items) {
    var length = items.length;
    //Number of passes
    for (var i = 0; i < length; i++) { 
        //Notice that j < (length - i)
        for (var j = 0; j < (length - i - 1); j++) { 
            //Compare the adjacent positions
            if(items[j] > items[j+1]) {
                //Swap the numbers
                var tmp = items[j];  //Temporary variable to hold the current number
                items[j] = items[j+1]; //Replace current number with adjacent number
                items[j+1] = tmp; //Replace adjacent number with current number
            }
        }        
    }
}

Method 3

function bubbleSort() {
    var numElements = this.dataStore.length;
    var temp;
    for (var outer = numElements; outer >= 2; --outer) {
        for (var inner = 0; inner <= outer-1; ++inner) {
            if (this.dataStore[inner] > this.dataStore[inner+1]) {
                swap(this.dataStore, inner, inner+1); }
        }
        console.log(this.toString()); 
    }
}

Answer 6

I believe that in a bubble sort, once the i loop has completed an iteration, then the i'th element is now in its correct position. That means that you should write the j loop as

for (var j = i + 1; j < records.length; j++)

Otherwise your bubble sort will be (even more) inefficient.