Javascript: Bubble Sort

Question

I have made a bubble sort algorithm (sorta) using JS. It works sometimes, but the problem is that it only iterates through the array once. Here is my code:

function bubble(arr) {
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] > arr[i + 1]) {
      var a = arr[i]
      var b = arr[i + 1]
      arr[i] = b
      arr[i + 1] = a
    }
  }
  return arr;
}

Answer 1

Bubble sort with a while loop and ES6 array elements swap.

Time Complexity: O(n^2)

Space Complexity: O(1)

const bubbleSort = (inputArr) => {
    let sorted = false;
    let arrayLength = inputArr.length;
    while(!sorted){
        sorted = true;
        for(let x=0;x < arrayLength;x++){
            if(x+1 < arrayLength && inputArr[x] > inputArr[x+1]){
                [inputArr[x], inputArr[x+1]] = [inputArr[x+1], inputArr[x]];
                sorted = false;
            }
        }
    }
    return inputArr;
}

console.log("Bubble sort");
console.log(bubbleSort([3,7,8,9,1,5,2]));

If you like to explore more about bubble sort, please have a look - Understanding The Bubble Sort: Simple Sorting Explained

Answer 2

Bubble sort using no-swap method

const bubbleSort = (arr) => {
    let noSwaps;
    for(let i=arr.length; i>=0; i--) {
        noSwaps = true;
        for(let j=0; j<i; j++) {
            if(arr[j] > arr[j+1]) {
                //SWAP!!
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
                noSwaps = false;
            }
        }
        if(noSwaps) break;
    }
    return arr;
}

console.log(bubbleSort([8,1,2,3,4,5,6]));

Answer 3

var array = [6,2,3,7,5,4,1];
function bubbleSort(arr) {
    for(let j=0;j<arr.length;j++) {
        for(let i = 0; i < arr.length; i++) {
            if(arr[i]>arr[i+1] && (i+1 < arr.length)) {
                var temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
    }      
    return arr;
}
console.log(bubbleSort(array));

Answer 4

Another way would be like this:

function bubbleSort(arr) {
  let swapped;

  do {
    swapped = false;

    for (var i = 0; i < arr.length; i++) {
      if (arr[i] > arr[i + 1]) {
        swapped = true;
        var tmp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = tmp;
      }
    }
  } while (swapped);

  return arr;
}

let myArray = [8, 1, 2, 5, 51, 13, 15, 33, 123, 100, 22];

console.log(bubbleSort(myArray));

Explanation:
In this function we are going to declare a swapped variable that is being set to false inside the DO WHILE loop, this is being done as a fail-safe not to end up with an infinite loop.

Inside the loop, we have another FOR loop which iterates through the given array and checks if the current value is greater than the next (which we don't want, we need ascending order).

When the IF the condition is true, we are going to swap the variables and assign true for the swapped variable, this is done because we want to keep on the DO WHILE loop untill everything is sorted.

Answer 5

function bubbleSort(array) {
  var done = false;
  while (!done) {
   //alert(1)
    done = true;
    for (var i = 1; i < array.length; i += 1) {
      if (array[i - 1] > array[i]) {
      //alert(2)
       
        done = false;
        var tmp = array[i - 1];
        array[i - 1] = array[i];
        array[i] = tmp;
      }
    }
  }

  return array;
}

Answer 6

const bubbleSort = (inputArr) => {
  const len = inputArr.length;

  for (let i = 0; i < len; i++) {
    for (let j = 0; j < len; j++) {
      if (inputArr[j] > inputArr[j + 1]) {
        let tmp = inputArr[j];
        inputArr[j] = inputArr[j + 1];
        inputArr[j + 1] = tmp;
      }
    }
  }

  return inputArr;
};

const numbers = [50, 30, 10, 40, 60];

console.log(bubbleSort(numbers));

// Output: [ 10, 30, 40, 50, 60 ]

Answer 7

Another bubble sort implementation:

const bubbleSort = array => {
  const arr = Array.from(array); // avoid side effects
  for (let i = 1; i < arr.length; i++) {
    for (let j = 0; j < arr.length - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      }
    }
  }
  return arr;
};

Answer 8

You need another loop:

var arr = [2, 1]
for(let i = 0;i<arr.length;i++){
    for(let b = 0; b<arr.length;i++){
        if(arr[b] > arr[b+1]){
            var first = arr[b]
            var second = arr[b + 1]
            arr[b] = second
            arr[b + 1] = first
        }
    }
}

Hope this helps I would recommend using quick sort if you want a high efficiency though.

Answer 9

Try this (performance upgrade):

function bubbleSort(inputArr, reverse = false) {
    const len = inputArr.length;
    for (let i = 0; i < len; i++) {
        for (let j = i + 1; j < len; j++) {
            let a = inputArr[i];
            let b = inputArr[j];
            if (reverse ? a < b : a > b) {
                const tmp = inputArr[j];
                inputArr[j] = inputArr[i];
                inputArr[i] = tmp;
            }
        }
    }
    return inputArr;
}

Use:

arr = [234,2,4,100, 1,12,5,23,12];
console.log(bubbleSort(arr)); // or console.log(bubbleSort(arr, true));

Answer 10

var arr = [5, 3, 4, 1, 2, 6];

function sort (arr) {
    for(let i=0; i < arr.length - 1; i++) {
        if(arr[i] > arr[i+1]) {
            let b = arr[i+1];

            arr[i+1] = arr[i];
            arr[i] = b;

            i = -1; // Resets the loop
        }
    }

    return arr;
}

console.log(sort(arr));

Answer 11

package hasan;

public class hssd {

public static void main(String[] args) {


 int t=9;
int g=20;



 for (t=g;t>19;++t){

    System.out.println(7);
   int f=12;
   int r=15;

    for(r=f;r>5;++r)
        System.out.println(r+1000000000+"*"+1000000000);
    }
}

}

Answer 12

It works for me. I commented the code for more understanding

bubbleSort = (numbersArray) => {
  const arrayLenght = numbersArray.length;

  for (let i = 0; i < arrayLenght; i++) {
    for(let j = 0; j < arrayLenght; j++) {
      // Print only to debug
      // console.log(`i: ${i} - j: ${j}`);
      // console.log(`numbersArray[i]: ${numbersArray[i]} | numbersArray[j]: ${numbersArray[j]}`);
    
      // Check if current number is greater than the next number
      if (numbersArray[j] > numbersArray[j + 1]) {
        // Store current value to generate swap
        const currentNumber = numbersArray[j];

        // Now the current position get value of the next position
        // And de next position get value of the current position
        numbersArray[j] = numbersArray[j + 1];
        numbersArray[j + 1] = currentNumber; 
      } 
    }
  }

  // Debug: Print the sorted array
  console.log(`sorted array: ${numbersArray.toString()}`);
}

const numbers = [
  [3, 10, 5, 7],
  [8, 5, 2, 9, 5, 6, 3],
  [4, 50, 28, 47, 9, 2097, 30, 41, 11, 3, 68],
  [3, 10, 5, 7, 8, 5, 2, 9, 5, 6, 3]
];

numbers.forEach(element => {
  bubbleSort(element);
});

Output:

• sorted array: 3,5,7,10
• sorted array: 2,3,5,5,6,8,9
• sorted array: 3,4,9,11,28,30,41,47,50,68,2097
• sorted array: 2,3,3,5,5,5,6,7,8,9,10

Answer 13

const bubbleSort = (array)=>{
  let sorted = false;

  let counter =0;

  while(!sorted){
    sorted = true;  
    for(let i =0; i < array.length -1 -counter; i++){

      if(array[i] > array[i+1]){
        helper(i,i+1,array);        
        sorted = false;
      }
    } 
    counter++;
  }
  return array;

}

//swap function
function helper(i,j, array){
  return [array[i],array[j]] = [array[j],array[i]]
}

let array=[8,5,2,9,5,6,3];

console.log(bubbleSort(array))

Answer 14

Another form of bubble sort includes starting at the end of the array and placing the smallest element first and going till the largest. This is the code:

function bubbleSort(items) {  
    var length = items.length;
    for (var i = (length - 1); i >= 0; i--) {
        //Number of passes
        for (var j = (length - i); j > 0; j--) {
            //Compare the adjacent positions
            if (items[j] < items[j - 1]) {
                //Swap the numbers
                var tmp = items[j];
                items[j] = items[j - 1];
                items[j - 1] = tmp;
            }
        }
    }
}

Note Bubble sort is one of the slowest sorting algorithms.

Answer 15

function bubble(arr) {//You need Two Loops for Bubble sort
  for (var i = 0; i < arr.length; i++) {//Outer Loop
   for(var j=0; j < arr.length - 1; j++){//Inner Loop
    if (arr[j] > arr[j + 1]) {
      var a = arr[j]
      var b = arr[j + 1]
      arr[j] = b
      arr[j + 1] = a
     }
   }
  }
  return arr;
}

Answer 16

My bubble sort with just a while loop :

function bubbleSort(arr){
  var sorted = false
  while (!sorted){
    sorted = true;
    arr.forEach(function (element, index, array){
      if (element > array[index+1]) {
        array[index] = array[index+1];
        array[index+1] = element;
        sorted = false;
      }
    });
  }
}

Answer 17

Please look at the following sequence:

[5, 4, 3, 2, 1]

Now lets say you need to sort this in the ascending order using bubble sort.

So, you iterate the array and swap adjacent elements which are ordered otherwise.

Here is what you will get after the completion of the iteration

[4, 3, 2, 1, 5]

Now if you do this another time, you will get this:

[3, 2, 1, 4, 5]

Likewise, you need to repeat the iteration enough times to get it sorted fully. This means you need 2 nested loops. The inner loop is to iterate the array and the outer loop is to repeat the iteration.

Please see the step-by-step example of this article.

Answer 18

You need an inner loop to complete the sort correctly:

function bubble(arr) {
      var len = arr.length;
    
      for (var i = 0; i < len ; i++) {
        for(var j = 0 ; j < len - i - 1; j++){ // this was missing
        if (arr[j] > arr[j + 1]) {
          // swap
          var temp = arr[j];
          arr[j] = arr[j+1];
          arr[j + 1] = temp;
        }
       }
      }
      return arr;
    }

document.write(bubble([1,9,2,3,7,6,4,5,5]));