# Java Program to Sort 2D Array Across Left Diagonal

In the field of data structure, the vector is a growable class array of a particular object. The vector class falls in the legacy class which is fully compatible with the collections. In java.util package, the List interface can use all the methods listed here. Here is the initial capacity is 10 and the general method is −

Vector<E> v = new Vector<E>();


The compare() method accepts two parameters and then compare each other by using Java environment logic.

## Algorithm to sort 2D array across left diagonal

Here is the particular algorithm to sort the 2D array across left diagonal.

• Step 1 − Start.

• Step 2 − Traverse all left diagonal one by one.

• Step 3 − Add elements on that left diagonal in the vector.

• Step 4 − Process those vectors.

• Step 5 − Sort them again.

• Step 6 − Push them back from vector to left diagonal.

• Step 7 − Remove that all vectors to make the set empty.

• Step 8 − Start fresh sorting again.

• Step 9 − Repeat the all steps again.

• Step 10 − Complete all the left diagonals like this step by step.

• Step 11 − Terminate the process.

### Syntax to sort 2D array across left diagonal

Here we have some particular syntaxes to shot some 2D arrays across the left diagonal as follows:

A. removeAll():

Syntax:

Vector.removeAll(Vectors As Value)
It is used to remove all the elements from the vector.


B. Collections.sort():

Syntax:

Collections.sort(Vectors As Value)
This method is used to sort the vector in a process.


Syntax:

Vector.add(Value as the integer value)
It is used to add some elements in the vector.


D. get():

Syntax:

Vector.get(3);
This method used to store the vector element at a pricular index.


Here in these particular syntaxes we have tried to sort some 2D arrays across the left diagonal.

### Approach to sort 2D array across left diagonal

• Approach 1 − Java Program to Sort 2D Array Across Left Diagonal

• Approach 2 − Java program to sort the 2D matrix diagonally in decreasing order

• Approach 3 − Java program to sort the 2D matrix diagonally and get its sum

## Java Program to Sort 2D Array Across Left Diagonal

In this Java code we have tried to show how to sort a 2D array across the left diagonal in a general manner.

### Example 1

import java.io.*;
import java.lang.*;
import java.util.*;
public class ARBRDD {
public static void main(String[] args)
throws java.lang.Exception{
int[][] arr = { { 5, 2, 0, 7, 1 }, { 3, 4, 2, 9, 14 },
{ 5, 1, 3, 5, 2 }, { 4, 2, 6, 2, 1 },
{ 0, 6, 3, 5, 1 }, { 1, 4, 7, 2, 8 } };
System.out.println("Matrix without sorting data is here ----> \n");
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}

Vector<Integer> v = new Vector<>();
for (int i = 0; i < 5; i++) {
}
Collections.sort(v);
for (int j = 0; j < 5; j++) {
arr[j][j] = v.get(j);
}

System.out.println("Matrix after sorting data is here ----> \n");

for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}


### Output

Matrix without sorting data is here ---->

5 2 0 7 1
3 4 2 9 14
5 1 3 5 2
4 2 6 2 1
0 6 3 5 1
Matrix after sorting data is here ---->

1 2 0 7 1
3 2 2 9 14
5 1 3 5 2
4 2 6 4 1
0 6 3 5 5


## Java program to sort the 2D matrix diagonally in decreasing order

In this Java code we have tried to show how to sort a 2D array matrix across the left diagonal in a decreasing manner.

### Example 2

import java.io.*;
import java.util.*;

public class ARBRDD {
public static void
diagonalSort(ArrayList<ArrayList<Integer> > mat){

int row = mat.size();
int col = mat.get(0).size();
ArrayList<ArrayList<Integer> > Neg = new ArrayList<ArrayList<Integer> >();
ArrayList<ArrayList<Integer> > Pos = new ArrayList<ArrayList<Integer> >();

int i, j;

for (i = 0; i < row; i++) {
ArrayList<Integer> temp
= new ArrayList<Integer>();
}

for (j = 0; j < col; j++) {
ArrayList<Integer> temp
= new ArrayList<Integer>();
}
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) {
if (j < i) {
}
else if (i < j) {
}
else {
}
}
}

for (i = 0; i < row; i++) {
Collections.sort(Neg.get(i));
;
}
for (i = 0; i < col; i++) {
Collections.sort(Pos.get(i));
;
}
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) {
if (j < i) {
int d = i - j;
int l = Neg.get(d).size();
mat.get(i).set(j,
Neg.get(d).get(l - 1));
Neg.get(d).remove(l - 1);
}
else if (i < j) {
int d = j - i;
int l = Pos.get(d).size();
mat.get(i).set(j,
Pos.get(d).get(l - 1));
Pos.get(d).remove(l - 1);
}
else {
int l = Pos.get(0).size();
mat.get(i).set(j,
Pos.get(0).get(l - 1));
Pos.get(0).remove(l - 1);
}
}
}

for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) {
System.out.print(mat.get(i).get(j) + " ");
}
System.out.println();
}
}
public static void main(String[] args){
ArrayList<ArrayList<Integer> > arr
= new ArrayList<ArrayList<Integer> >();
ArrayList<Integer> row1 = new ArrayList<Integer>();

ArrayList<Integer> row2 = new ArrayList<Integer>();

ArrayList<Integer> row3 = new ArrayList<Integer>();

diagonalSort(arr);

}
}


### Output

10 6 3
8 9 2
7 4 5


## Java program to sort the 2D matrix diagonally and get its sum

In this Java code we have tried to show how to sort a 2D array matrix across the left diagonal and get its sum.

### Example 3

import java.util.*;

public class ARBRDD{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int i,j,row,col,sum=0;
System.out.println("Enter the number of rows ---->:");
row = sc.nextInt();
System.out.println("Enter the number of columns---->:");
col = sc.nextInt();

int[][] mat = new int[row][col];

System.out.println("Enter the elements of the matrix: -----@") ;
for(i=0;i<row;i++){
for(j=0;j<col;j++){
mat[i][j] = sc.nextInt();
}
}
System.out.println("####The elements of the matrix we get####") ;
for(i=0;i<row;i++){
for(j=0;j<col;j++){
System.out.print(mat[i][j]+"\t");
}
System.out.println("");
}
for(i=0;i<row;i++){
for(j=0;j<col;j++){
if(i==j)  {
sum = sum + mat[i][j];
}
}
}
System.out.printf("Sum of the diagonal elements of the matrix is here = "+sum) ;
}
}


### Output

Enter the number of rows ---->:
3
Enter the number of columns---->:
3
Enter the elements of the matrix: -----@
1 2 3
4 5 6
7 8 9
####The elements of the matrix####
1	2	3
4	5	6
7	8	9
Sum of the diagonal elements of the matrix is here = 15


## Conclusion

Here in this article, we have discussed the sorting of 2D array problem in details. Today we have used here various sorting methods to solve this problem by the above mentioned syntax and algorithm. Hope with this article you have gained the broad view about how to sort 2D array across left diagonal problem by using a Java environment.

Updated on: 13-Apr-2023

216 Views