Sorting rows of matrix in ascending order followed by columns in descending order

Given a matrix, sort the rows of matrix in ascending order followed by sorting the columns in descending order. 
Examples :

Input : a[3][3] = {{1, 2, 3},
                  {4, 5, 6}, 
                  {7, 8, 9}};
Output : 7 8 9
         4 5 6
         1 2 3

Input : a[3][3] = {{3, 2, 1},
                  {9, 8, 7}, 
                  {6, 5, 4}};
Output : 7 8 9
         4 5 6
         1 2 3

Approach:

• Traverse all rows one by one and sort rows in ascending order using a simple array sort. 
• Convert matrix to its transpose
• Again sort all rows, but this time in descending order. 
• Again convert a matrix to its transpose

Below is the implementation of the above approach:

C++

// C++ implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order
#include <bits/stdc++.h>
using namespace std;

#define MAX_SIZE 10

// function to sort each row of the matrix
// according to the order specified by
// ascending.
void sortByRow(int mat[][MAX_SIZE], int n,
                           bool ascending)
{
    for (int i = 0; i < n; i++)
    {
      if (ascending)
        sort(mat[i], mat[i] + n);
      else
          sort(mat[i], mat[i] + n, greater<int>());
    }
}

// function to find transpose of the matrix
void transpose(int mat[][MAX_SIZE], int n)
{
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)

            // swapping element at index (i, j)
            // by element at index (j, i)
            swap(mat[i][j], mat[j][i]);
}

// function to sort the matrix row-wise
// and column-wise
void sortMatRowAndColWise(int mat[][MAX_SIZE],
                                       int n)
{
    // sort rows of mat[][]
    sortByRow(mat, n, true);

    // get transpose of mat[][]
    transpose(mat, n);

    // again sort rows of mat[][] in descending
    // order.
    sortByRow(mat, n, false);

    // again get transpose of mat[][]
    transpose(mat, n);
}

// function to print the matrix
void printMat(int mat[][MAX_SIZE], int n)
{
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            cout << mat[i][j] << " ";
        cout << endl;
    }
}

// Driver program to test above
int main()
{
    int n = 3;

    int mat[n][MAX_SIZE]  = {{3, 2, 1},
                            {9, 8, 7},
                            {6, 5, 4}};

    cout << "Original Matrix:\n";
    printMat(mat, n);

    sortMatRowAndColWise(mat, n);

    cout << "\nMatrix After Sorting:\n";
    printMat(mat, n);

    return 0;
}

Java

// Java implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order
import java.util.Arrays;
import java.util.Collections;

class GFG
{
    static int MAX_SIZE=10;

    // function to sort each row of the matrix
    // according to the order specified by
    // ascending.
    static void sortByRow(Integer mat[][], int n,
                                 boolean ascending)
    {
        for (int i = 0; i < n; i++)
        {
            if (ascending)
                Arrays.sort(mat[i]);
            else
                Arrays.sort(mat[i],Collections.reverseOrder());
        }
    }

    // function to find transpose of the matrix
    static void transpose(Integer mat[][], int n)
    {
        for (int i = 0; i < n; i++)
            for (int j = i + 1; j < n; j++)
            {
                // swapping element at index (i, j)
                // by element at index (j, i)
                int temp = mat[i][j];
                mat[i][j] = mat[j][i];
                mat[j][i] = temp;
            }
    }

    // function to sort the matrix row-wise
    // and column-wise
    static void sortMatRowAndColWise(Integer mat[][],
                                              int n)
    {
        // sort rows of mat[][]
        sortByRow(mat, n, true);

        // get transpose of mat[][]
        transpose(mat, n);

        // again sort rows of mat[][] in descending
        // order.
        sortByRow(mat, n, false);

        // again get transpose of mat[][]
        transpose(mat, n);
    }

    // function to print the matrix
    static void printMat(Integer mat[][], int n)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
                System.out.print(mat[i][j] + " ");
            System.out.println();
        }
    }

    // Driver code
    public static void main (String[] args)
    {
        int n = 3;

        Integer mat[][] = {{3, 2, 1},
                           {9, 8, 7},
                           {6, 5, 4}};

        System.out.print("Original Matrix:\n");
        printMat(mat, n);

        sortMatRowAndColWise(mat, n);

        System.out.print("\nMatrix After Sorting:\n");
        printMat(mat, n);
    }
}

// This code is contributed by Anant Agarwal.

Python3

# Python implementation to sort the rows
# of matrix in ascending order followed by
# sorting the columns in descending order

MAX_SIZE=10

# function to sort each row of the matrix
# according to the order specified by
# ascending.
def sortByRow(mat, n, ascending):

    for i in range(n):
        if (ascending):
            mat[i].sort()
        else:
            mat[i].sort(reverse=True)

# function to find
# transpose of the matrix
def transpose(mat, n):

    for i in range(n):
        for j in range(i + 1, n):

            # swapping element at index (i, j)
            # by element at index (j, i)
            temp = mat[i][j]
            mat[i][j] = mat[j][i]
            mat[j][i] = temp

# function to sort
# the matrix row-wise
# and column-wise
def sortMatRowAndColWise(mat, n):

    # sort rows of mat[][]
    sortByRow(mat, n, True)

    # get transpose of mat[][]
    transpose(mat, n)

    # again sort rows of
    # mat[][] in descending
    # order.
    sortByRow(mat, n, False)

    # again get transpose of mat[][]
    transpose(mat, n)

# function to print the matrix
def printMat(mat, n):

    for i in range(n):
        for j in range(n):
            print(mat[i][j] , " ", end="")
        print()

#Driver code
n = 3

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

print("Original Matrix:")
printMat(mat, n)

sortMatRowAndColWise(mat, n)

print("Matrix After Sorting:")
printMat(mat, n)

# This code is contributed
# by Anant Agarwal.

C#

// C# implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order
using System;

public static class GFG {

    // function to sort each row of the matrix
    // according to the order specified by
    // ascending.
    static void sortByRow(int[, ] m)
    {
        // loop for rows of matrix
        for (int i = 0; i < m.GetLength(0); i++) {

            // loop for column of matrix
            for (int j = 0; j < m.GetLength(1); j++) {

                // loop for comparison and swapping
                for (int k = 0; k < m.GetLength(1) - j - 1;
                     k++) {
                    if (m[i, k] > m[i, k + 1]) {

                        // swapping of elements
                        int t = m[i, k];
                        m[i, k] = m[i, k + 1];
                        m[i, k + 1] = t;
                    }
                }
            }
        }
    }

    static void reverseArray(int[, ] arr)
    {

        // Traverse each row of [,]arr
        for (int i = 0; i < arr.GetLength(1); i++) {

            // Initialise start and end index
            int start = 0;
            int end = arr.GetLength(0) - 1;

            // Till start < end, swap the element
            // at start and end index
            while (start < end) {

                // Swap the element
                int temp = arr[i, start];
                arr[i, start] = arr[i, end];
                arr[i, end] = temp;

                // Increment start and decrement
                // end for next pair of swapping
                start++;
                end--;
            }
        }
    }

    // function to find transpose of the matrix
    public static void transpose(int[, ] mat, int n)
    {
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {

                // swapping element at index (i, j)
                // by element at index (j, i)
                int temp = mat[i, j];
                mat[i, j] = mat[j, i];
                mat[j, i] = temp;
            }
        }
    }

    // function to sort the matrix row-wise
    // and column-wise
    public static void sortMatRowAndColWise(int[, ] mat,
                                            int n)
    {
        // sort rows of mat[][]
        sortByRow(mat);

        // get transpose of mat[][]
        transpose(mat, n);

        // again sort rows of mat[][] in descending
        // order.
        sortByRow(mat);
        reverseArray(mat);

        // again get transpose of mat[][]
        transpose(mat, n);
    }

    // function to print the matrix
    public static void printMat(int[, ] mat, int n)
    {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                Console.Write(mat[i, j]);
                Console.Write(" ");
            }
            Console.Write("\n");
        }
    }

    // Driver program to test above
    internal static void Main()
    {
        int n = 3;

        int[, ] mat
            = { { 3, 2, 1 }, { 9, 8, 7 }, { 6, 5, 4 } };

        Console.Write("Original Matrix:\n");
        printMat(mat, n);

        sortMatRowAndColWise(mat, n);

        Console.Write("\nMatrix After Sorting:\n");
        printMat(mat, n);
    }
}

// This code is contributed by Aarti_Rathi

PHP

<?php
// PHP implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order
$MAX_SIZE = 10;

// function to sort each row of the matrix
// according to the order specified by
// ascending.
function sortByRow(&$mat, $n, $ascending)
{
    for ($i = 0; $i < $n; $i++)
    {
        if ($ascending)
            sort($mat[$i]);
        else
            rsort($mat[$i]);
    }
}

// function to find transpose
// of the matrix
function transpose(&$mat, $n)
{
    for ($i = 0; $i < $n; $i++)
    {
        for ($j = $i + 1; $j < $n; $j++)
        {
            // swapping element at index (i, j)
            // by element at index (j, i)
            $temp = $mat[$i][$j];
            $mat[$i][$j] = $mat[$j][$i];
            $mat[$j][$i] = $temp;
        }
    }
}

// function to sort the matrix row-wise
// and column-wise
function sortMatRowAndColWise(&$mat, $n)
{
    // sort rows of mat[][]
    sortByRow($mat, $n, true);

    // get transpose of mat[][]
    transpose($mat, $n);

    // again sort rows of mat[][] in
    // descending order.
    sortByRow($mat, $n, false);

    // again get transpose of mat[][]
    transpose($mat, $n);
}

// function to print the matrix
function printMat(&$mat, $n)
{
    for ($i = 0; $i < $n; $i++)
    {
        for ($j = 0; $j < $n; $j++)
            echo $mat[$i][$j] . " ";
        echo "\n" ;
    }
}

// Driver Code
$n = 3;

$mat = array(array(3, 2, 1),
             array(9, 8, 7),
             array(6, 5, 4));

echo "Original Matrix:\n";
printMat($mat, $n);

sortMatRowAndColWise($mat, $n);

echo "\nMatrix After Sorting:\n";
printMat($mat, $n);

// This code is contributed by Ita_c
?>

Javascript

<script>
// Javascript implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order

    let MAX_SIZE=10;

    // function to sort each row of the matrix
    // according to the order specified by
    // ascending.
    function sortByRow(mat,n,ascending)
    {
        for (let i = 0; i < n; i++)
        {
            if (ascending)
                mat[i].sort(function(a,b){return a-b;});
            else
                mat[i].sort(function(a,b){return b-a;});
        }
    }

    // function to find transpose of the matrix
    function transpose(mat,n)
    {
        for (let i = 0; i < n; i++)
            for (let j = i + 1; j < n; j++)
            {
                // swapping element at index (i, j)
                // by element at index (j, i)
                let temp = mat[i][j];
                mat[i][j] = mat[j][i];
                mat[j][i] = temp;
            }
    }

    // function to sort the matrix row-wise
    // and column-wise
    function sortMatRowAndColWise(mat,n)
    {
        // sort rows of mat[][]
        sortByRow(mat, n, true);

        // get transpose of mat[][]
        transpose(mat, n);

        // again sort rows of mat[][] in descending
        // order.
        sortByRow(mat, n, false);

        // again get transpose of mat[][]
        transpose(mat, n);
    }

    // function to print the matrix
    function printMat(mat,n)
    {
        for (let i = 0; i < n; i++)
        {
            for (let j = 0; j < n; j++)
                document.write(mat[i][j] + " ");
            document.write("<br>");
        }
    }

    // Driver code
    let n = 3;

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

    document.write("Original Matrix:<br>");
    printMat(mat, n);

    sortMatRowAndColWise(mat, n);

    document.write("\nMatrix After Sorting:<br>");
    printMat(mat, n);


    // This code is contributed by avanitrachhadiya2155
</script>

Output

Original Matrix:
3 2 1 
9 8 7 
6 5 4 

Matrix After Sorting:
7 8 9 
4 5 6 
1 2 3 

Time Complexity: O(N² log N)
Auxiliary Space: O(1), since no extra space has been taken.