Sort an array containing numbers using a 'for' loop

First create an empty array where the sorted numbers will be pushed into.

let sorted = [];

Secondly, create a very large amount of numbers that none of the numbers of the array can match. This number will be used for the very first comparison to determine which number of the array is smaller.

let comparison = 9000000000;

Create a for loop.

This loop will have another loop inside of it. The inner loop will check for the smallest number in a given array, and once the smallest number is gotten, it will be push into the empty array we created. The smallest number will also be removed from the initial array and then the array will run again.

for(a = 0; a < arr.length; a++){

    //This inner loop fetches the smallest number.
    for(b = 0; b < arr.length; a++){
        if(comparison > arr[b]){
            comparison = arr[b];
        }
    }

    // The smallest number is assigned to comparison
    // Now it being pushed to the empty array
    sorted.push(comparison);

    // Remove the smallest number from the initial array

    let indexOfSmallNumber = arr.indexOf(comparison);
    arr.splice(indexOfSmallNumber, 1);

    // Set the comparison back to 9000000000;
    comparison = 90000000000;

    a = -1;
    // Here, "a" is our main loop index counter and we are
    // setting it to -1 because we don't want it to change
    // to 2 by default, doing this will make the loop run
    // forever until the initial array is empty.
}

let arr = [4, 2, 5, 1]
let temp;

function converter(arr) {

  for(let i=0; i<arr.length; i++) {

    for (let j=i+1; j<arr.length; j++) {

      if(arr[i] > arr[j]) {

        temp = arr[i]
        arr[i] = arr[j]
        arr[j] = temp
      }
    }
  }
  return arr
}

const newArr = converter(arr)
console.log(newArr)

Use:

let s = [4, 6, 3, 1, 2];
for (let i = 0; i < s.length;) {
    if (s[i] > s[i + 1]) {
        let a = s[i];
        s[i] = s[i + 1];
        s[i + 1] = a;
        i--;
    }
    else {
        i++;
    }
}

This is a sorting algorithm which has a best time complexity of O(n) and the worst time of O(n^2).

This code checks for each number, and then compares to all numbers on the left side.

To check the time it takes each code to run, you can also use this code below:

let start = process.hrtime.bigint()
let end = process.hrtime.bigint()

console.log(end - start) // This measures the time used in nano seconds.

Also for microseconds, you can use this performance.now().

Here there is a very simple solution that uses a temporary array to store the values greater than the current one. Then it puts the current value between the lesser and the greater values:

var arr = [2,4,8,1,5,9,3,7,6];
var res = [];
for (const c of arr) {
    let tmp = [];
    while (c < res[res.length-1]) {
        tmp.unshift(res.pop());
    }
    res = [...res, c, ...tmp];
} 

const numberArr = [5, 9, 2, 8, 4, 10, 1, 3, 7, 6];

function sortedFunction(arr) {
  let sortedArr = [];
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      let n = 0;
      if (arr[i] > arr[j]) {
        n = arr[i];
        arr[i] = arr[j];
        arr[j] = n;
      }
    }
    sortedArr.push(arr[i]);
  }
  return sortedArr;
}
sortedFunction(numberArr);

Under the JavaScript array sort section of W3Schools it talks about how to compare a value in an array with the others and then order them based on the values being returned. I updated the code to use a for loop to sort values.

// Ascending points
var points = [5.0, 3.7, 1.0, 2.9, 3.4, 4.5];
var output = [];
var i;
for (i = 0; i < points.length; i++) {
    points.sort(function (a, b) {
        return a - b
    });
    output += points[i] + "<br>";
}
console.log(output);

// Descending points
var points = [5.0, 3.7, 1.0, 2.9, 3.4, 4.5];
var output = [];
var i;
for (i = 0; i < points.length; i++) {
    points.sort(function (a, b) {
        return b - a
    });
    output += points[i] + "<br>";
}
console.log(output);

const array = [12, 3, 45, 61, 23, 45, 6, 7];

function sortArray(array) {
    for (var i = 0; i < array.length; ++i) {
        for (var j = 0; j < array.length - 1 - i; ++j) {
            if (array[j] > array[j + 1]) {
                [array[j], array[j + 1]] = [array[j + 1], array[j]];
            }
        }
    }
    return array;
}

console.log(sortArray(array));

Here are the two solutions for the same algorithm:

Solution 1:

We can directly use JavaScript functions:

let arr = [2, 4, 8, 1, 5, 9, 3, 7, 6]

const changeOrder = (arr) => {
    return arr.sort((a, b) => a - b)
}

let result = changeOrder(arr);

console.log(result) // [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Solution 2:

We can use a JavaScript for loop for doing the same

let arr = [2, 4, 8, 1, 5, 9, 3, 7, 6]

const changeOrder = (arr) => {
    for(let i=1; i< arr.length; i++) {
        for(let j=0; j < i; j++) {
            if(arr[i] < arr[j]) {
                let x = arr[i]
                arr[i] = arr[j]
                arr[j] = x
            }
        }
    }
    return arr;
}

let result = changeOrder(arr);
console.log(result) // [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]