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(N2 log N)
Auxiliary Space: O(1), since no extra space has been taken.