Java program to sort 2D array left diagonally-javaTutorial-php.cn

Java program to sort 2D array left diagonally

In the field of data structures, vector is a growable class array of specific objects. The vector class is a legacy class and is fully compatible with collections. In the java.util package, the List interface can use all the methods listed here. The initial capacity here is 10, and the general method is −

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

Copy after login

The compare() method accepts two parameters and then uses Java environment logic to compare.

Algorithm for sorting 2D arrays by left diagonal

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

Step one - start.
Step 2 - Traverse all left diagonals one by one.
Step 3 − Add elements on that left diagonal in the vector.
Step 4 - Process these vectors.
Step 5 - Sort again.
Step 6 − Push them back from vector to left diagonal.
Step 7 - Remove all vectors so that the set is empty.
Step 8 - Start a fresh sort again.
Step 9 - Repeat all steps again.
Step 10 - Work your way through all the left diagonal lines.
Step 11 - Terminate the process.

Syntax for sorting a 2D array on the left diagonal

Here we have some specific syntax to take some 2D array along the left diagonal as shown below:

A. removeAll():

Syntax:

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

Copy after login

B. Collections.sort():

Syntax:

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

Copy after login

C. add():

Syntax:

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

Copy after login

D. get():

Syntax:

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

Copy after login

In these particular syntaxes, we try to sort some 2D arrays along the left diagonal.

Method to sort 2D array left diagonally

Method 1 - Java program to sort 2D array according to left diagonal
Method 2 - Java program to sort 2D matrix in decreasing diagonal order
Method 3 - Java program to sort a 2D matrix diagonally and get its sum

Java program: Sort 2D array according to the 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.

The Chinese translation of

Example 1

is:

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++) {
         v.add(arr[i][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();
      }
   }
}

Copy after login

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

Copy after login

Java program to sort 2D matrix in decreasing diagonal order

In this Java code, we try to show how to sort a 2D array matrix along the left diagonal in a descending manner.

The Chinese translation of

Example 2

is:

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>();
      	Neg.add(temp);
      }

      for (j = 0; j < col; j++) {
      	ArrayList<Integer> temp
            = new ArrayList<Integer>();
      	Pos.add(temp);
      }
      for (i = 0; i < row; i++) {
      	for (j = 0; j < col; j++) {
            if (j < i) {
            	Neg.get(i - j).add(mat.get(i).get(j));
            }
            else if (i < j) {
            	Pos.get(j - i).add(mat.get(i).get(j));
            }
            else {
            	Pos.get(0).add(mat.get(i).get(j));
            }
      	}
      }

      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>();
      row1.add(10);
      row1.add(2);
      row1.add(3);
      arr.add(row1);

      ArrayList<Integer> row2 = new ArrayList<Integer>();
      row2.add(4);
      row2.add(5);
      row2.add(6);
      arr.add(row2);

      ArrayList<Integer> row3 = new ArrayList<Integer>();
      row3.add(7);
      row3.add(8);
      row3.add(9);
      arr.add(row3);

      diagonalSort(arr);

	}
}

Copy after login

Output

10 6 3 
8 9 2 
7 4 5

Copy after login

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

In this Java code, we try to show how to sort a 2D array matrix along 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) ;
   }	
}

Copy after login

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

Copy after login

in conclusion

In this article, we discussed in detail the problem of sorting 2D arrays. Today we use various sorting methods based on the above grammar and algorithm to solve this problem. Hopefully, through this article, you will be able to get a broad understanding of the problem of how to sort a 2D array by using left diagonal in Java environment.

The above is the detailed content of Java program to sort 2D array left diagonally. For more information, please follow other related articles on the PHP Chinese website!