Programme Java pour trier un tableau 2D à gauche en diagonale

Dans le domaine des structures de données, le vecteur est un tableau de classes extensibles d'objets spécifiques. La classe vector est une classe héritée et est entièrement compatible avec les collections. Dans le package java.util, l'interface List peut utiliser toutes les méthodes répertoriées ici. La capacité initiale ici est de 10, et la méthode générale est −

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

La méthode

compare() accepte deux paramètres et utilise ensuite la logique d'environnement Java pour comparer.

Algorithme de tri des tableaux 2D par diagonale gauche

Voici l'algorithme particulier pour trier le tableau 2D sur la diagonale gauche.

• Première étape : commencez.

• Étape 2 - Parcourez toutes les diagonales de gauche une par une.

• Étape 3 - Ajoutez des éléments sur cette diagonale gauche dans le vecteur.

• Étape 4 - Traitez ces vecteurs.

• Étape 5 - Triez à nouveau.

• Étape 6 - Repoussez-les du vecteur vers la diagonale gauche.

• Étape 7 - Supprimez tous les vecteurs rendant l'ensemble vide.

• Étape 8 - Recommencez un nouveau tri.

• Étape 9 - Répétez à nouveau toutes les étapes.

• Étape 10 - Étape par étape pour compléter toutes les lignes diagonales gauche.

• Étape 11 - Tuez le processus.

Syntaxe pour trier un tableau 2D sur la diagonale gauche

Nous avons ici une syntaxe spécifique pour prendre un tableau 2D le long de la diagonale gauche, comme indiqué ci-dessous :

A.removeAll() :

Syntaxe :

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

B.Collections.sort()：

Syntaxe :

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

C.ajouter() :

Syntaxe :

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

D. obtenir() :

Syntaxe :

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

Dans ces syntaxes particulières, nous essayons de trier certains tableaux 2D le long de la diagonale gauche.

Comment trier un tableau 2D à gauche en diagonale

• Méthode 1 - Programme Java pour trier un tableau 2D selon la diagonale gauche

• Méthode 2 – Programme Java pour trier la matrice 2D par ordre diagonal décroissant

• Méthode 3 - Programme Java pour trier une matrice 2D en diagonale et obtenir sa somme

Programme Java : Trier un tableau 2D selon la diagonale gauche

Dans ce code Java, nous avons essayé de montrer comment trier un tableau 2D sur la diagonale gauche de manière générale.

La traduction chinoise de

Exemple 1

est :

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

Sortie

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 

Programme Java pour trier la matrice 2D par ordre diagonal décroissant

Dans ce code Java, nous essayons de montrer comment trier une matrice de tableau 2D le long de la diagonale gauche de manière décroissante.

La traduction chinoise de

Exemple 2

est :

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

	}
}

Sortie

10 6 3 
8 9 2 
7 4 5

Programme Java pour trier la matrice 2D en diagonale et obtenir sa somme

Dans ce code Java, nous essayons de montrer comment trier une matrice de tableau 2D le long de la diagonale gauche et obtenir sa somme.

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

Sortie

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

Dans cet article, nous avons abordé en détail le problème du tri des tableaux 2D. Aujourd'hui, nous utilisons diverses méthodes de tri basées sur la grammaire et l'algorithme ci-dessus pour résoudre ce problème. Espérons que grâce à cet article, vous serez en mesure d'acquérir une compréhension globale du problème du tri d'un tableau 2D en utilisant la diagonale gauche dans un environnement Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!