Skip to content
Related Articles
Sort a 2D vector diagonally
• Difficulty Level : Medium
• Last Updated : 18 May, 2021

Given a 2D vector of NxM integers. The task is to sort the elements of the vectors diagonally from top-left to bottom-right in decreasing order.
Examples:

Input: arr[][] = { { 10, 2, 3 }, { 4, 5, 6 }, {7, 8, 9 } }
Output:
10 2 0
4 9 0
0 0 5
Input: arr[][] = { { 10, 2, 43 }, { 40, 5, 16 }, { 71, 8, 29 }, {1, 100, 5} }
Output:
29 2 0
8 10 0
71 5 5
0 0 0

Approach:
Observations:

The above images show the difference between the column index and row index at each cell. The cells having the same difference from top-left to bottom-down cell forms a diagonal.
Below are the steps to sort diagonal in decreasing order:

1. Store the diagonal element with a positive difference in one Array of Vectors(say Pos[]) such that elements at the cell having difference(say a) is stored at index an of Pos[] array.
2. Store the diagonal element with the negative difference in another Array of Vectors(say Neg[]) such that elements at the cell having difference(say -b) is stored at index abs(-b) = b of Neg[] array.
3. Sort both the Array of Vectors increasing order.
4. Traverse the given 2D vector and updated the value at the current cell with the value stored in Pos[] and Neg[] array.
• If the difference between column and row index(say d) is positive, then updated the value from Pos[d] array and remove the last element as:

```d = i - j
arr[i][j] = Pos[d][Pos.size()-1]
Pos[d].pop_back()```
• If the difference between column and row index(say d) is negative, then updated the value from Neg[d] array and remove the last element as:
```d = j - i
arr[i][j] = Neg[d][Neg.size()-1]
Neg[d].pop_back()```

Below is the implementation of the above approach:

## CPP

 `// C++ program to sort the 2D vector``// diagonally in decreasing order``#include "bits/stdc++.h"``using` `namespace` `std;` `// Function that sort the elements``// of 2D vector``void` `diagonalSort(vector >& mat)``{` `    ``// Calculate the rows and column``    ``int` `row = mat.size();``    ``int` `col = mat[0].size();` `    ``// Array of vectors to store the``    ``// diagonal elements``    ``vector<``int``> Neg[row];``    ``vector<``int``> Pos[col];` `    ``// Traverse the 2D vector and put``    ``// element in Array of vectors at``    ``// index difference between indexes``    ``for` `(``int` `i = 0; i < row; i++) {``        ``for` `(``int` `j = 0; j < col; j++) {` `            ``// If diff is negative, then``            ``// push element to Neg[]``            ``if` `(j < i) {``                ``Neg[i - j].push_back(mat[i][j]);``            ``}` `            ``// If diff is positive, then``            ``// push element to Pos[]``            ``else` `if` `(j > i) {``                ``Pos[j - i].push_back(mat[i][j]);``            ``}` `            ``// If diff is 0, then push``            ``// element to Pos[0]``            ``else` `{``                ``Pos[0].push_back(mat[i][j]);``            ``}``        ``}``    ``}` `    ``// Sort the Array of vectors``    ``for` `(``int` `i = 0; i < row; i++) {``        ``sort(Neg[i].begin(), Neg[i].end());``    ``}``    ``for` `(``int` `i = 0; i < col; i++) {``        ``sort(Pos[i].begin(), Pos[i].end());``    ``}` `    ``// Update the value to arr[][]``    ``// from the sorted Array of vectors``    ``for` `(``int` `i = 0; i < row; i++) {``        ``for` `(``int` `j = 0; j < col; j++) {` `            ``// If diff is positive``            ``if` `(j < i) {``                ``int` `d = i - j;``                ``int` `l = Neg[d].size() - 1;``                ``mat[i][j] = Neg[d][l - 1];``                ``Neg[d].pop_back();``            ``}` `            ``// If diff is negative``            ``else` `if` `(j > i) {``                ``int` `d = j - i;``                ``int` `l = Pos[d].size() - 1;``                ``mat[i][j] = Pos[d][l - 1];``                ``Pos[d].pop_back();``            ``}` `            ``// If diff is 0``            ``else` `{``                ``int` `l = Pos[0].size();``                ``mat[i][j] = Pos[0][l - 1];``                ``Pos[0].pop_back();``            ``}``        ``}``    ``}``}` `// Function to print element``void` `printElement(vector >& arr)``{` `    ``// Traverse the 2D vector``    ``for` `(``int` `i = 0; i < arr.size(); i++) {``        ``for` `(``int` `j = 0; j < arr[0].size(); j++) {``            ``cout << arr[i][j] << ``' '``;``        ``}``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``vector > arr``        ``= { { 10, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };``    ``diagonalSort(arr);` `    ``// Function call to print elements``    ``printElement(arr);``}`

## Python3

 `# Python program for the above approach``from` `collections ``import` `defaultdict` `def` `diagonalSort(matrix, n, m):``  ` `    ``# make a dict of list, where we``    ``# wil store the diagonal elements``    ``to ``=` `defaultdict(``list``)` `    ``# store the diagonal elements with``    ``# respect to their row-col value``    ``# remember every row-col value for``    ``# each diagonal will be different``    ``for` `row ``in` `range``(n):``        ``for` `col ``in` `range``(m):``            ``to[row``-``col].append(matrix[row][col])` `    ``# sort the elements of each``    ``# diagonal as required``    ``for` `i ``in` `to:``      ` `        ``# upper triangle diagonals``        ``if` `i < ``0``:``            ``to[i].sort(reverse``=``True``)` `        ``# median``        ``elif` `i ``=``=` `0``:``            ``pass` `        ``# lower triangle diagonals``        ``else``:``            ``to[i].sort()` `    ``# store the new diagonal elements to``    ``# their respective position in the matrix``    ``for` `row ``in` `range``(n):``        ``for` `col ``in` `range``(m):``            ``matrix[row][col] ``=` `to[row``-``col].pop(``0``)` `    ``return` `matrix` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``matrix ``=` `[[``10``, ``2``, ``3``],``              ``[``4``, ``5``, ``6``],``              ``[``7``, ``8``, ``9``]]` `    ``n ``=` `len``(matrix)``    ``m ``=` `len``(matrix[``0``])``    ``matrix ``=` `diagonalSort(matrix, n, m)` `    ``for` `row ``in` `range``(n):``        ``for` `col ``in` `range``(m):``            ``print``(matrix[row][col], end``=``' '``)``        ``print``()`
Output:
```10 2 0
4 9 0
0 0 5```

Time Complexity: O(N*M*log(min(N,M)))

Space Complexity: O(N*M)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up