Sorting an array of numbers by element size is a common task in programming. One approach to achieve this is by using the selection sort algorithm.

The selection sort algorithm works by repeatedly finding the minimum element from the unsorted part of the array and moving it to the beginning. The steps involved in the algorithm are as follows:

  1. We start by selecting the first element of the array.
  2. We then compare this element with the second element. If the second element is smaller, we swap them.
  3. Next, we compare the first element with every other element in the array, finding the smallest element among them.
  4. Once we find the smallest element, we swap it with the second element.
  5. We continue this process, moving to the next element and finding the minimum among the remaining unsorted elements.
  6. Finally, we repeat the process until the entire array is sorted.

It’s important to note that the selection sort algorithm has a complexity of O(n^2), where n is the number of elements in the array. This means that as the size of the array grows, the time it takes to sort the array increases exponentially.

Here’s an implementation of the selection sort algorithm in JavaScript:

const selectionSort = (originalList) => {
  const list = [...originalList]; // Copying the array to avoid modifying the original
  const len = list.length;

  for (let i = 0; i < len; i++) {
    let min = i;

    for (let j = i + 1; j < len; j++) {
      if (list[min] > list[j]) {
        min = j;
      }
    }

    if (min !== i) {
      // Swapping the new minimum with the current element
      [list[i], list[min]] = [list[min], list[i]];
    }
  }

  return list;
};

const listOfNumbers = [1, 6, 3, 4, 5];
console.log(selectionSort(listOfNumbers)); // [1, 3, 4, 5, 6]

By using the selection sort algorithm, we can effectively sort an array of numbers in ascending or descending order. Keep in mind that this algorithm is not the most efficient for large arrays, but it can be used for smaller ones or as a basis to understand more advanced sorting algorithms.