GeeksforGeeks App
Open App
Browser
Continue

# Sort Matrix in alternating ascending and descending order rowwise

Given an N x N matrix, our task is to print the row of the matrix in ascending and descending order alternatively.
Examples:

Input:
5 7 3 4
9 5 8 2
6 3 8 1
5 8 9 3
Output:
3 4 5 7
9 8 5 2
1 3 6 8
9 8 5 3
Explanation:
Here the first row is sorted in ascending order, second row sorted in descending order, third row sorted in ascending order and so on.
Input:
7 3 4
3 8 2
3 6 1
Output:
3 4 7
8 3 2
1 3 6
Explanation:
Here the first row is sorted in ascending order, second row sorted in descending order, third row sorted in ascending order.

Approach to solve
To solve the problem mentioned above we iterate 0 to N and check if the ith row is even or odd, if it is even then we sort the row in ascending order otherwise sort the ith row in descending order. Return the matrix after N iterations.
Below is the implementation of the above approach:

## C++

 `// C++ implementation to print row of``// matrix in ascending or descending``// order alternatively` `#include ``#define N 4` `void` `func(``int` `a[][N])``{` `    ``// Iterate matrix rowwise``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Sort even rows in ascending order``        ``if` `(i % 2 == 0) {``            ``for` `(``int` `j = 0; j < N; j++) {``                ``for` `(``int` `k = j + 1; k < N; ++k) {` `                    ``// compare adjacent elements``                    ``if` `(a[i][j] > a[i][k]) {` `                        ``// swap adjacent element``                        ``int` `temp = a[i][j];``                        ``a[i][j] = a[i][k];``                        ``a[i][k] = temp;``                    ``}``                ``}``            ``}``        ``}` `        ``// Sort even rows in descending order``        ``else` `{``            ``for` `(``int` `j = 0; j < N; j++) {``                ``for` `(``int` `k = j + 1; k < N; ++k) {` `                    ``// compare adjacent elements``                    ``if` `(a[i][j] < a[i][k]) {` `                        ``// swap adjacent element``                        ``int` `temp = a[i][j];``                        ``a[i][j] = a[i][k];``                        ``a[i][k] = temp;``                    ``}``                ``}``            ``}``        ``}``    ``}` `    ``// Printing the final Output``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``            ``printf``(``"%d "``, a[i][j]);``        ``}``        ``printf``(``"\n"``);``    ``}``}` `// Driver code``int` `main()``{` `    ``int` `a[N][N] = {``        ``{ 5, 7, 3, 4 },``        ``{ 9, 5, 8, 2 },``        ``{ 6, 3, 8, 1 },``        ``{ 5, 8, 9, 3 }``    ``};` `    ``func(a);` `    ``return` `0;``}`

## Java

 `// Java implementation to print row of``// matrix in ascending or descending``// order alternatively``import` `java.io.*;``class` `GFG{``    ` `static` `int` `N = ``4``;` `static` `void` `func(``int` `a[][])``{``    ``int` `i, j, k;``    ` `    ``// Iterate matrix rowwise``    ``for``(i = ``0``; i < N; i++)``    ``{``        ` `       ``// Sort even rows in ascending order``       ``if` `(i % ``2` `== ``0``)``       ``{``           ``for``(j = ``0``; j < N; j++)``           ``{``              ``for``(k = j + ``1``; k < N; ++k)``              ``{``                  ` `                 ``// Compare adjacent elements``                 ``if` `(a[i][j] > a[i][k])``                 ``{``                     ` `                     ``// Swap adjacent element``                     ``int` `temp = a[i][j];``                     ``a[i][j] = a[i][k];``                     ``a[i][k] = temp;``                 ``}``              ``}``           ``}``       ``}``       ` `       ``// Sort even rows in descending order``       ``else``       ``{``           ``for``(j = ``0``; j < N; j++)``           ``{``              ``for``(k = j + ``1``; k < N; ++k)``              ``{``                  ` `                 ``// Compare adjacent elements``                 ``if` `(a[i][j] < a[i][k])``                 ``{``                     ` `                     ``// Swap adjacent element``                     ``int` `temp = a[i][j];``                     ``a[i][j] = a[i][k];``                     ``a[i][k] = temp;``                 ``}``              ``}``           ``}``       ``}``    ``}``    ` `    ``// Printing the final Output``    ``for``(i = ``0``; i < N; i++)``    ``{``       ``for``(j = ``0``; j < N; j++)``       ``{``          ``System.out.print(a[i][j] + ``" "``);``       ``}``       ``System.out.print(``"\n"``);``    ``}``}` `// Driver code``public` `static` `void` `main (String []args)``{` `    ``int` `a[][] = { { ``5``, ``7``, ``3``, ``4` `},``                  ``{ ``9``, ``5``, ``8``, ``2` `},``                  ``{ ``6``, ``3``, ``8``, ``1` `},``                  ``{ ``5``, ``8``, ``9``, ``3` `} };` `    ``func(a);``}``}` `// This code is contributed by chitranayal`

## Python3

 `# Python3 implementation to print row of``# matrix in ascending or descending``# order alternatively``N ``=` `4` `def` `func(a):``    ` `    ``# Iterate matrix rowwise``    ``for` `i ``in` `range``(N):` `        ``# Sort even rows in ascending order``        ``if` `i ``%` `2` `=``=` `0``:``            ``for` `j ``in` `range``(N):``                ``for` `k ``in` `range``(j ``+` `1``, N):``                    ` `                    ``# Compare adjacent elements``                    ``if` `a[i][j] > a[i][k]:``                        ` `                        ``# Swap adjacent element``                        ``temp ``=` `a[i][j]``                        ``a[i][j] ``=` `a[i][k]``                        ``a[i][k] ``=` `temp` `        ``# Sort even rows in descending order``        ``else` `:``            ``for` `j ``in` `range``(N):``                ``for` `k ``in` `range``(j ``+` `1``, N):` `                    ``# Compare adjacent elements``                    ``if` `a[i][j] < a[i][k]:` `                        ``# Swap adjacent element``                        ``temp ``=` `a[i][j]``                        ``a[i][j] ``=` `a[i][k]``                        ``a[i][k] ``=` `temp` `    ``# Printing the final output``    ``for` `i ``in` `range``(N):``        ``for` `j ``in` `range``(N):``            ``print``(a[i][j], end ``=` `" "``)``        ``print``()``        ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``a ``=` `[ [ ``5``, ``7``, ``3``, ``4` `],``          ``[ ``9``, ``5``, ``8``, ``2` `],``          ``[ ``6``, ``3``, ``8``, ``1` `],``          ``[ ``5``, ``8``, ``9``, ``3` `] ]``          ` `    ``func(a)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation to print row of``// matrix in ascending or descending``// order alternatively``using` `System;``class` `GFG{``    ` `static` `int` `N = 4;` `static` `void` `func(``int``[,]a)``{``    ``int` `i, j, k;``    ` `    ``// Iterate matrix rowwise``    ``for``(i = 0; i < N; i++)``    ``{``        ` `       ``// Sort even rows in ascending order``       ``if` `(i % 2 == 0)``       ``{``           ``for``(j = 0; j < N; j++)``           ``{``              ``for``(k = j + 1; k < N; ++k)``              ``{``                  ` `                 ``// Compare adjacent elements``                 ``if` `(a[i, j] > a[i, k])``                 ``{``                     ` `                     ``// Swap adjacent element``                     ``int` `temp = a[i, j];``                     ``a[i, j] = a[i, k];``                     ``a[i, k] = temp;``                 ``}``              ``}``           ``}``       ``}``       ` `       ``// Sort even rows in descending order``       ``else``       ``{``           ``for``(j = 0; j < N; j++)``           ``{``              ``for``(k = j + 1; k < N; ++k)``              ``{``                  ` `                 ``// Compare adjacent elements``                 ``if` `(a[i, j] < a[i, k])``                 ``{``                     ` `                     ``// Swap adjacent element``                     ``int` `temp = a[i, j];``                     ``a[i, j] = a[i, k];``                     ``a[i, k] = temp;``                 ``}``              ``}``           ``}``       ``}``    ``}``    ` `    ``// Printing the readonly Output``    ``for``(i = 0; i < N; i++)``    ``{``       ``for``(j = 0; j < N; j++)``       ``{``          ``Console.Write(a[i, j] + ``" "``);``       ``}``       ``Console.Write(``"\n"``);``    ``}``}` `// Driver code``public` `static` `void` `Main(String []args)``{` `    ``int``[,]a = { { 5, 7, 3, 4 },``                ``{ 9, 5, 8, 2 },``                ``{ 6, 3, 8, 1 },``                ``{ 5, 8, 9, 3 } };` `    ``func(a);``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``

Output:

```3 4 5 7
9 8 5 2
1 3 6 8
9 8 5 3```

Time Complexity: O(N3)
Auxiliary Space: O(1)

Efficient approach: We can optimize the above approach by sorting any given row by using the sort() function. It will sort any given row in O(n*log(n)) time complexity.

Steps involved in the approach:

1. Traverse through each row and check if the row is at an even number or odd.
2. If even row is there then sort it in ascending order by directly using the sort function.
3. If odd row then sort it in descending order by passing the “greater()” function in sort.

Below is the code for the above approach:

## C++

 `// C++ implementation to print row of``// matrix in ascending or descending``// order alternatively` `#include ``using` `namespace` `std;``#define N 4` `void` `func(``int` `a[][N])``{` `    ``// Iterate matrix rowwise``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Sort even rows in ascending order``        ``if` `(i % 2 == 0) {``            ``sort(a[i],a[i]+N);``        ``}` `        ``// Sort even rows in descending order``        ``else` `{``            ``sort(a[i],a[i]+N,greater<``int``>());``        ``}``    ``}` `    ``// Printing the final Output``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``            ``printf``(``"%d "``, a[i][j]);``        ``}``        ``printf``(``"\n"``);``    ``}``}` `// Driver code``int` `main()``{` `    ``int` `a[N][N] = {``        ``{ 5, 7, 3, 4 },``        ``{ 9, 5, 8, 2 },``        ``{ 6, 3, 8, 1 },``        ``{ 5, 8, 9, 3 }``    ``};` `    ``func(a);` `    ``return` `0;``}` `// This code is contributed by Pushpesh Raj`

## Java

 `import` `java.util.Arrays;``import` `java.util.Collections;` `public` `class` `Main {``  ``public` `static` `void` `func(Integer[][] a) {``    ``for` `(``int` `i = ``0``; i < a.length; i++) {``      ``if` `(i % ``2` `== ``0``) {``         ``Arrays.sort(a[i]);``      ``} ``else` `{``    ``Arrays.sort(a[i], Collections.reverseOrder());``   ``}``  ``}``   ``for` `(``int` `i = ``0``; i < a.length; i++) {``     ``for` `(``int` `j = ``0``; j < a[i].length; j++) {``        ``System.out.print(a[i][j] + ``" "``);``        ``}``        ``System.out.println();``        ``}``      ``}`  `public` `static` `void` `main(String[] args) {``    ``Integer[][] a = {{``5``, ``7``, ``3``, ``4``}, {``9``, ``5``, ``8``, ``2``}, {``6``, ``3``, ``8``, ``1``}, {``5``, ``8``, ``9``, ``3``}};``    ``func(a);``  ``}``}`

## Python

 `import` `numpy as np` `def` `func(a):``    ``for` `i ``in` `range``(``len``(a)):``        ``if` `i ``%` `2` `=``=` `0``:``            ``a[i] ``=` `np.sort(a[i])``        ``else``:``            ``a[i] ``=` `np.sort(a[i])[::``-``1``]``    ``for` `i ``in` `range``(``len``(a)):``        ``for` `j ``in` `range``(``len``(a[i])):``            ``print``(a[i][j])``        ``print``()` `a ``=` `np.array([[``5``, ``7``, ``3``, ``4``], [``9``, ``5``, ``8``, ``2``], [``6``, ``3``, ``8``, ``1``], [``5``, ``8``, ``9``, ``3``]])``func(a)`

## Javascript

 `function` `func(a) {``    ``for` `(let i = 0; i < a.length; i++) {``        ``if` `(i % 2 === 0) {``            ``a[i].sort((a, b) => a - b);``        ``} ``else` `{``            ``a[i].sort((a, b) => b - a);``        ``}``    ``}``    ``for` `(let i = 0; i < a.length; i++) {``        ``for` `(let j = 0; j < a[i].length; j++) {``            ``console.log(a[i][j]);``        ``}``        ``console.log(``"\n"``);``    ``}``}` `let a = [[5, 7, 3, 4], [9, 5, 8, 2], [6, 3, 8, 1], [5, 8, 9, 3]];``func(a);`

## C#

 `using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `MainClass {``  ``public` `static` `void` `func(``int``[][] a) {``    ``for` `(``int` `i = 0; i < a.Length; i++) {``      ``if` `(i % 2 == 0) {``        ``Array.Sort(a[i]);``      ``} ``else` `{``        ``Array.Sort(a[i], ``new` `Comparison<``int``>((x, y) => y.CompareTo(x)));``        ``// Using Comparison delegate to sort in reverse order``      ``}``    ``}` `    ``for` `(``int` `i = 0; i < a.Length; i++) {``      ``for` `(``int` `j = 0; j < a[i].Length; j++) {``        ``Console.Write(a[i][j] + ``" "``);``      ``}``      ``Console.WriteLine();``    ``}``  ``}` `  ``public` `static` `void` `Main (``string``[] args) {``    ``int``[][] a = ``new` `int``[][] {``        ``new` `int``[] {5, 7, 3, 4},``        ``new` `int``[] {9, 5, 8, 2},``        ``new` `int``[] {6, 3, 8, 1},``        ``new` `int``[] {5, 8, 9, 3}``    ``};``    ``func(a);``  ``}``}`

Output

```3 4 5 7
9 8 5 2
1 3 6 8
9 8 5 3 ```

Time Complexity: O(N2log(N))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up