Alternative Sorting of an Array using JavaScript

Alternative sorting means we have to arrange the elements of an array in such a way that the first element is the first maximum and the second element is the first minimum, the third element is the second maximum, the fourth element is the second minimum, and so on.

Example:

Input: array = [5, 6, 2, 4, 3, 1]

Output: array = [6, 1, 5, 2, 4, 3] 

Explanation:
Sorting the array: [1, 2, 3, 4, 5, 6]
First element (1) from the sorted array. 
Last element (6) from the sorted array.
Second element (2) from the sorted array.
Second-to-last element (5) from the sorted array.
Third element (3) from the sorted array.
Third-to-last element (4) from the sorted array
Now reordered the array: [6, 1, 5, 2, 4, 3]

Below are the approaches for Alternative sorting of an array using JavaScript:

Sorting and Rearranging

In this approach, sort an array and then rearranges it in an alternating high-low order in JavaScript. It first sorts the array in ascending order, then uses a while loop to alternately push the largest remaining element and the smallest remaining element to a new array. The final array is returned and logged.

Example: The example below shows Alternative sorting of an array using Sorting and Rearranging.

function alternativeSort(arr) {
    arr.sort((a, b) => a - b);
    let answer = [];
    let start = 0, end = arr.length - 1;
    while (start <= end) {
        answer.push(arr[end--]);
        if (start <= end) {
            answer.push(arr[start++]);
        }
    }
    return answer;
}

const arr1 = [5, 6, 2, 4, 3, 1];
console.log("Sorted Array with Alternative Sorting:",
                            alternativeSort(arr1));

Sorted Array with Alternative Sorting: [ 6, 1, 5, 2, 4, 3 ]

Time complexity: O(n log n)

Space complexity: O(n)

Using Two Arrays

Sort the array in ascending order. Divide the sorted array into two halves where maxArray, containing elements from the middle index to the end, reversed and minArray, containing elements from the start to the middle index. Create an empty result array. Iterate over maxArray and minArray alternately, pushing elements into the result array. If one array has fewer elements, handle them appropriately. Return the result array.

Example: The example below shows Alternative sorting of an array using Two Arrays.

function alternativeSort(arr) {
    arr.sort((a, b) => a - b);

    // Calculate the middle index
    const mid = Math.ceil(arr.length / 2);

    // Split the array into two halves
    const maxArray = arr.slice(mid).reverse();
    const minArray = arr.slice(0, mid);

    // Interleave the two arrays
    const result = [];
    for (let i = 0; i < mid; i++) {
        result.push(maxArray[i]);
        if (minArray[i] !== undefined) {
            result.push(minArray[i]);
        }
    }
    return result;
}
const arr = [5, 6, 2, 4, 3, 1];
console.log("Sorted Array with Alternative Sorting:",
                            alternativeSort(arr));

Sorted Array with Alternative Sorting: [ 6, 1, 5, 2, 4, 3 ]

Time complexity: O(n log n).

Space complexity: O(n).