JavaScript: Reorder an array to alternate between largest and smallest elements, starting with the largest

Question

JavaScript: Reorder an array to alternate between largest and smallest elements, starting with the largest

When working with an array of integers that need to be sorted in a specific order, such as:

[1, -1, -3, 9, -2, -5, 4, 8,]

We must rearrange them so that the largest number is followed by the smallest number, then the second largest number followed by the second smallest number, and so on.

[9, -5, 8, -3,  4, -2, 1, -1 ]

While it's clear how to find the first largest and smallest numbers manually, making this process dynamic for all values in the array can be more challenging.

One approach involves using two variables, such as firstSmallest and firstLargest, pointing to the first and last index of the sorted array. By iterating through the array, we can increment firstSmallest and decrement firstLargest to store the desired arrangement into a new output array.

let unsortedArr = [1, 5, 8 , 7, 6, -1, -5, 4, 9, 5]

let output = [];

function meanderArray(unsorted){
  let sorted = unsorted.sort((a, b) => a-b);
  let firstSmallest = sorted[0];
  let firstLargest = sorted[unsorted.length-1];

  for(let i = 0; i <= sorted.length; i++){
  //Increment firstSmallest and decrement firstLargest to generate the desired output
  } 
 return output;
}
meanderArray(unsortedArr);
console.log(output);

javascript

Answer 1

Answer №1

You can utilize a toggle object to select either the first or last property from an array and continue iterating until there are no more items left.

function alternateArray([...array]) {
    const 
        result = [],
        toggle = { shift: 'pop', pop: 'shift' };

    let fn = 'shift';

    array.sort((a, b) => a - b);

    while (array.length) result.push(array[fn = toggle[fn]]());

    return result;
}

console.log(...alternateArray([1, 5, 8, 7, 6, -1, -5, 4, 9, 5]));

Answer 2

You can utilize a toggle object to select either the first or last property from an array and continue iterating until there are no more items left.

function alternateArray([...array]) {
    const 
        result = [],
        toggle = { shift: 'pop', pop: 'shift' };

    let fn = 'shift';

    array.sort((a, b) => a - b);

    while (array.length) result.push(array[fn = toggle[fn]]());

    return result;
}

console.log(...alternateArray([1, 5, 8, 7, 6, -1, -5, 4, 9, 5]));

Answer 3

Answer №2

If you want to arrange an array in descending order, here's a neat logic for you: start by taking the first element from the beginning and the end of the array, then move on to the second element from the beginning and the second-to-last element, and so forth.

let nums = [1, 5, 8 , 7, 6, -1, -5, 4, 9, 5]

let arrangedArray = [];

function meanderTheArray(arr){
  let sortedArr = arr.sort((a, b) => b-a);
  let result = []

  for(let index = 0; index < sortedArr.length/2; index++){
    result.push(sortedArr[index])
    if(index !== sortedArr.length - 1 - index){
      result.push(sortedArr[sortedArr.length - 1 - index])
    }
  } 
 return result;
}
let finalResult = meanderTheArray(nums);
console.log(finalResult);

Answer 4

If you want to arrange an array in descending order, here's a neat logic for you: start by taking the first element from the beginning and the end of the array, then move on to the second element from the beginning and the second-to-last element, and so forth.

let nums = [1, 5, 8 , 7, 6, -1, -5, 4, 9, 5]

let arrangedArray = [];

function meanderTheArray(arr){
  let sortedArr = arr.sort((a, b) => b-a);
  let result = []

  for(let index = 0; index < sortedArr.length/2; index++){
    result.push(sortedArr[index])
    if(index !== sortedArr.length - 1 - index){
      result.push(sortedArr[sortedArr.length - 1 - index])
    }
  } 
 return result;
}
let finalResult = meanderTheArray(nums);
console.log(finalResult);

Answer 5

Answer №3

To organize the data, you can first sort it and then use pop() to extract the last number and shift() to retrieve the first number.

let unsortedArr = [1, -1, -3, 9, -2, -5, 4, 8,]
let output = [];

function rearrangeArray(unsorted){
    let sorted = unsorted.sort((a, b) => a - b);

    for(let i = 0; i < unsortedArr.length + 2; i++){
        output.push(sorted.pop());
        output.push(sorted.shift());
    } 
console.log(output);
return output;
}

rearrangeArray(unsortedArr);

Answer 6

To organize the data, you can first sort it and then use pop() to extract the last number and shift() to retrieve the first number.

let unsortedArr = [1, -1, -3, 9, -2, -5, 4, 8,]
let output = [];

function rearrangeArray(unsorted){
    let sorted = unsorted.sort((a, b) => a - b);

    for(let i = 0; i < unsortedArr.length + 2; i++){
        output.push(sorted.pop());
        output.push(sorted.shift());
    } 
console.log(output);
return output;
}

rearrangeArray(unsortedArr);

Answer 7

Answer №4

Revolutionary Meandering Array technique outperforming all previously mentioned solutions.

Based on the results from JSBench.me, this approach stands out as the fastest, supported by a screenshot provided below for your convenience.

While devising my own method for creating a Meandering Array, I stumbled upon an approach that closely resembles the solution proposed by elvira.genkel.

In my implementation, I began by sorting the input array and identifying its midpoint. Subsequently, I divided the sorted array into two subsets: one spanning indices from 0 to the middle index and the other covering from the middle index to the end of the sorted array.

To prevent encountering undefined values in the resulting array due to unequal lengths of the subarrays during the subsequent for() loop iteration, I took care to increment the length of the first subarray by one.

Hence, it is crucial to ensure that firstArr.length > secondArr.length at all times.

The objective was to generate a new array with elements arranged in a meandering fashion. To achieve this, I utilized a for() loop to interleave values from the beginning of the first subarray with those from the end of the second subarray, ensuring that the dynamically calculated index for the latter remains non-negative. Any negative index would introduce unwanted undefined values into the resulting Meandering Array.

This optimized solution aims to benefit coding enthusiasts who seek high-performance implementations :)

Your feedback and suggestions are highly appreciated.

const unsorted = [1, 5, 8, 7, 6, -1, -5, 4, 9, 5];
const sorted = unsorted.sort((a,b)=>a-b).reverse();
const half = Math.round(Math.floor(sorted.length/2)) + 1;
const leftArr = sorted.slice(0, half);
const rightArr = sorted.slice(half, sorted.length);
const newArr = [];

for(let i=0; i<leftArr.length; i++) {
 newArr.push(leftArr[i]);
 if (rightArr.length-1-i >= 0) {
   newArr.push(rightArr[rightArr.length-1-i]);
 }
}

https://i.sstatic.net/NlWNS.png

Answer 8