Java程式以左對角線排序2D數組

在資料結構領域中，vector是特定物件的可增長的類別數組。 vector類屬於遺留類，與集合完全相容。在java.util套件中，List介面可以使用這裡列出的所有方法。這裡的初始容量是10，一般方法是−

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

compare()方法接受兩個參數，然後使用Java環境邏輯進行比較。

對2D數組依左對角線排序的演算法

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

• 第一步 - 開始。

• 步驟 2 - 逐一遍歷所有左對角線。

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

• 第四步 - 處理這些向量。

• 第五步 - 再次進行排序。

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

• 第7步 - 刪除所有向量，使集合為空。

• 第8步 - 再次開始全新的排序。

• 第九步 - 再次重複所有步驟。

• 第10步 - 逐步完成所有左對角線。

• 第11步 - 終止進程。

在左對角線上對2D陣列進行排序的語法

在這裡，我們有一些特定的語法來沿著左對角線拍攝一些2D數組，如下所示：

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.

在這些特定的語法中，我們嘗試將一些2D陣列進行沿左對角線排序。

對2D陣列進行左對角線排序的方法

• 方法1 - Java程式對2D陣列依照左對角線排序

• 方法2 - Java程式以對角線遞減順序對2D矩陣進行排序

• #方法3 - Java程式對2D矩陣進行對角線排序並取得其總和

#Java程式：將2D陣列依照左對角線進行排序

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

的中文翻譯為：

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

輸出

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程式以對角線遞減順序對2D矩陣進行排序

在這段Java程式碼中，我們嘗試展示如何以遞減的方式對一個2D數組矩陣沿著左對角線進行排序。

Example 2

的中文翻譯為：

範例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);

	}
}

輸出

10 6 3 
8 9 2 
7 4 5

Java程式對2D矩陣進行對角線排序並取得其總和

在這段Java程式碼中，我們嘗試展示如何對一個2D數組矩陣沿著左對角線進行排序，並得到其總和。

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

輸出

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

結論

在本文中，我們詳細討論了對2D數組進行排序的問題。今天我們在上述語法和演算法的基礎上使用了各種排序方法來解決這個問題。希望透過本文，您能夠對如何在Java環境中透過使用左對角線對2D數組進行排序問題有廣泛的了解。

以上是Java程式以左對角線排序2D數組的詳細內容。更多資訊請關注PHP中文網其他相關文章！