Java-Programm zum diagonalen Sortieren von 2D-Arrays nach links

Im Bereich der Datenstrukturen ist Vektor ein erweiterbares Klassenarray spezifischer Objekte. Die Vektorklasse ist eine Legacy-Klasse und vollständig kompatibel mit Sammlungen. Im Paket java.util kann die List-Schnittstelle alle hier aufgeführten Methoden verwenden. Die anfängliche Kapazität beträgt hier 10 und die allgemeine Methode ist −

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

Die

compare()-Methode akzeptiert zwei Parameter und verwendet dann die Java-Umgebungslogik zum Vergleich.

Algorithmus zum Sortieren von 2D-Arrays nach der linken Diagonale

Hier ist der spezielle Algorithmus zum Sortieren des 2D-Arrays über die linke Diagonale.

• Schritt eins – loslegen.

• Schritt 2 – Alle linken Diagonalen nacheinander durchlaufen.

• Schritt 3 – Elemente auf der linken Diagonale im Vektor hinzufügen.

• Schritt 4 – Verarbeiten Sie diese Vektoren.

• Schritt 5 – Nochmals sortieren.

• Schritt 6 – Schieben Sie sie vom Vektor zurück in die linke Diagonale.

• Schritt 7 – Entfernen Sie alle Vektoren, wodurch der Satz leer wird.

• Schritt 8 – Beginnen Sie erneut mit einer neuen Sortierung.

• Schritt 9 – Wiederholen Sie alle Schritte noch einmal.

• Schritt 10 – Schritt für Schritt, um alle linken diagonalen Linien zu vervollständigen.

• Schritt 11 – Beenden Sie den Prozess.

Syntax zum Sortieren von 2D-Arrays auf der linken Diagonale

Hier haben wir eine spezielle Syntax, um ein 2D-Array entlang der linken Diagonale zu erstellen, wie unten gezeigt:

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.

C. add():

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.

In diesen speziellen Syntaxen versuchen wir, einige 2D-Arrays entlang der linken Diagonale zu sortieren.

Methode zum diagonalen Linkssortieren eines 2D-Arrays

• Methode 1 – Java-Programm zum Sortieren von 2D-Arrays nach der linken Diagonale

• Methode 2 – Java-Programm zum Sortieren der 2D-Matrix in diagonal absteigender Reihenfolge

• Methode 3 – Java-Programm, um eine 2D-Matrix diagonal zu sortieren und ihre Summe zu erhalten

Java-Programm: 2D-Array nach der linken Diagonale sortieren

In diesem Java-Code haben wir versucht zu zeigen, wie man ein 2D-Array allgemein über die linke Diagonale sortiert.

Die chinesische Übersetzung von

Beispiel 1

lautet:

Beispiel 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();
      }
   }
}

Ausgabe

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-Programm zum Sortieren von 2D-Matrix in diagonal absteigender Reihenfolge

In diesem Java-Code versuchen wir zu zeigen, wie eine 2D-Array-Matrix absteigend entlang der linken Diagonale sortiert wird.

Die chinesische Übersetzung von

Beispiel 2

lautet:

Beispiel 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);

	}
}

Ausgabe

10 6 3 
8 9 2 
7 4 5

Java-Programm zum diagonalen Sortieren einer 2D-Matrix und zum Ermitteln der Summe

In diesem Java-Code versuchen wir zu zeigen, wie man eine 2D-Array-Matrix entlang der linken Diagonale sortiert und ihre Summe erhält.

Beispiel 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) ;
   }	
}

Ausgabe

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

Fazit

In diesem Artikel haben wir das Problem der Sortierung von 2D-Arrays ausführlich besprochen. Heute verwenden wir verschiedene Sortiermethoden, die auf der oben genannten Grammatik und dem oben genannten Algorithmus basieren, um dieses Problem zu lösen. Wir hoffen, dass Sie durch diesen Artikel ein umfassendes Verständnis des Problems erhalten, wie ein 2D-Array mithilfe der linken Diagonale in einer Java-Umgebung sortiert wird.

Das obige ist der detaillierte Inhalt vonJava-Programm zum diagonalen Sortieren von 2D-Arrays nach links. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!