JavaScript Program to Sort the 2D Array Across Rows

We will see how to sort the 2D Array across rows using a Javascript program. we can sort the 2D Array Across Rows in many ways including Bubble Sort Algorithm, Array.prototype.sort() method, Insertion Sort Algorithm, Using the Selection Sort Algorithm, and Merge Sort Algorithm.

Example:

Input:
[[8 5 7 2],
[7 3 0 1],
[8 5 3 2],
[9 4 2 1]]
Output:
[[2, 5, 7, 8], [0, 1, 3, 7], [2, 3, 5, 8], [1, 2, 4, 9]]

These are the following approaches:

Using the Bubble Sort Algorithm

In this approach, we use Bubble Sort. First Start iterating through each row of the given 2D array, and sort elements of each row using the Bubble sort sorting algorithm. 

Example: Implementation of Sort the 2D Array Across Rows using the Bubble Sort Algorithm

Javascript

// Function to sort a 2D array
// across rows using Bubble Sort
function sort2DArrayAcrossRows(arr) {

    // Iterate through each row of the array
    for (let i = 0; i < arr.length; i++) {

        // Apply Bubble Sort 
        // to the current row
        for (let j = 0; j < arr[i].length - 1; j++) {
            for (let k = 0; k < arr[i].length - j - 1; k++) {
                if (arr[i][k] > arr[i][k + 1]) {

                    // Swap elements if 
                    // they are in the wrong order
                    let temp = arr[i][k];
                    arr[i][k] = arr[i][k + 1];
                    arr[i][k + 1] = temp;
                }
            }
        }
    }
    return arr;
}

const array2D = [
    [4, 2, 6, 1],
    [9, 5, 3, 8],
    [7, 1, 2, 0]
];

const sortedArray = sort2DArrayAcrossRows(array2D);
console.log(sortedArray);

Output

[ [ 1, 2, 4, 6 ], [ 3, 5, 8, 9 ], [ 0, 1, 2, 7 ] ]

Using the Array.prototype.sort() method

In this approach, we use the Array.prototype.sort() method to iterate through each row of the 2D array and apply the sort() method with a custom comparison function to sort the elements in ascending order.

Example: Implementation of Sort the 2D Array Across Rows using the Array.prototype.sort() method

Javascript

// Function to sort a 2D array across rows 
//using Array.prototype.sort()
function sort2DArrayAcrossRows(arr) {

    // Iterate through each
    // row of the array and sort it
    return arr.map(row => row.slice()
        .sort((a, b) => a - b));
}

// Example usage:
const array2D = [
    [4, 2, 6, 1],
    [9, 5, 3, 8],
    [7, 1, 2, 0]
];

const sortedArray = sort2DArrayAcrossRows(array2D);
console.log(sortedArray);

Output

[ [ 1, 2, 4, 6 ], [ 3, 5, 8, 9 ], [ 0, 1, 2, 7 ] ]

Using the Insertion Sort Algorithm

In this approach, we use the insertion sort algorithm to iterate through each row of the array. Here we apply Insertion Sort to each row, which iteratively places each element in its correct position within the sorted subarray to its left. Continue this process until the entire row is sorted. Repeat this process for each row in the 2D array.

Example: Implementation of Sort the 2D Array Across Rows using the Insertion Sort Algorithm

Javascript

// Function to sort a 2D array
// across rows using Insertion Sort
function sort2DArrayAcrossRows(arr) {

    // Iterate through each row of the array
    for (let i = 0; i < arr.length; i++) {

        // Apply Insertion Sort to the current row
        for (let j = 1; j < arr[i].length; j++) {
            let current = arr[i][j];
            let k = j - 1;
            while (k >= 0 && arr[i][k] > current) {
                arr[i][k + 1] = arr[i][k];
                k--;
            }
            arr[i][k + 1] = current;
        }
    }
    return arr;
}

// Example usage:
const array2D = [
    [4, 2, 6, 1],
    [9, 5, 3, 8],
    [7, 1, 2, 0]
];

const sortedArray = sort2DArrayAcrossRows(array2D);
console.log(sortedArray);

Output

[ [ 1, 2, 4, 6 ], [ 3, 5, 8, 9 ], [ 0, 1, 2, 7 ] ]

Using the Selection Sort Algorithm

In this approach, we use selection sort to repeatedly selects the minimum element from the unsorted portion of the array and places it at the beginning and by continuing this process until the entire row is sorted. We repeat this process for each row to sort the 2D array.

Example: Implementation of Sort the 2D Array Across Rows using the selection sort algorithm

Javascript

// Function to sort a 2D array 
// across rows using Selection Sort
function sort2DArrayAcrossRows(arr) {

    // Iterate through each row of the array
    for (let i = 0; i < arr.length; i++) {

        // Apply Selection Sort to the current row
        for (let j = 0; j < arr[i].length - 1; j++) {
            let minIndex = j;
            for (let k = j + 1; k < arr[i].length; k++) {
                if (arr[i][k] < arr[i][minIndex]) {
                    minIndex = k;
                }
            }
            if (minIndex !== j) {
                let temp = arr[i][j];
                arr[i][j] = arr[i][minIndex];
                arr[i][minIndex] = temp;
            }
        }
    }
    return arr;
}

// Example usage:
const array2D = [
    [4, 2, 6, 1],
    [9, 5, 3, 8],
    [7, 1, 2, 0]
];

const sortedArray = sort2DArrayAcrossRows(array2D);
console.log(sortedArray);

Output

[ [ 1, 2, 4, 6 ], [ 3, 5, 8, 9 ], [ 0, 1, 2, 7 ] ]

Using the Merge Sort Algorithm

In this approach, we define functions to merge two sorted arrays and perform Merge Sort on a 1D array. Iterate through each row of the 2D array and apply Merge Sort, which recursively divides the array into halves until each half contains only one element, then merges them back together in sorted order. Repeat this process for each row in the 2D array.

Example: Implementation of Sort the 2D Array Across Rows Using the Merge Sort Algorithm

Javascript

// Function to merge two sorted arrays
function merge(left, right) {
    let result = [];
    let leftIndex = 0;
    let rightIndex = 0;

    while (leftIndex < left.length && 
           rightIndex < right.length) {
        if (left[leftIndex] < right[rightIndex]) {
            result.push(left[leftIndex]);
            leftIndex++;
        } else {
            result.push(right[rightIndex]);
            rightIndex++;
        }
    }

    return result.concat(left.slice(leftIndex))
                 .concat(right.slice(rightIndex));
}

// Function to perform merge sort on a 1D array
function mergeSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }

    const middle = Math.floor(arr.length / 2);
    const left = arr.slice(0, middle);
    const right = arr.slice(middle);

    return merge(mergeSort(left), mergeSort(right));
}

// Function to sort a 2D array
// across rows using Merge Sort
function sort2DArrayAcrossRows(arr) {
    
    // Iterate through each row of 
    // the array and apply Merge Sort
    return arr.map(row => mergeSort(row));
}

// Example usage:
const array2D = [
    [4, 2, 6, 1],
    [9, 5, 3, 8],
    [7, 1, 2, 0]
];

const sortedArray = sort2DArrayAcrossRows(array2D);
console.log(sortedArray);

Output

[ [ 1, 2, 4, 6 ], [ 3, 5, 8, 9 ], [ 0, 1, 2, 7 ] ]