Program Java untuk mengisih tatasusunan 2D ke kiri secara menyerong

Dalam bidang struktur data, vektor ialah tatasusunan kelas objek tertentu yang boleh tumbuh. Kelas vektor ialah kelas warisan dan serasi sepenuhnya dengan koleksi. Dalam pakej java.util, antara muka Senarai boleh menggunakan semua kaedah yang disenaraikan di sini. Kapasiti awal di sini ialah 10, dan kaedah umum ialah −

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

Kaedah

compare() menerima dua parameter dan kemudian menggunakan logik persekitaran Java untuk membandingkan.

Algoritma untuk mengisih tatasusunan 2D mengikut pepenjuru kiri

Berikut ialah algoritma khusus untuk mengisih tatasusunan 2D merentas pepenjuru kiri.

• Langkah pertama - mulakan.

• Langkah 2 - Lintas semua pepenjuru kiri satu demi satu.

• Langkah 3 − Tambahkan elemen pada pepenjuru kiri dalam vektor.

• Langkah 4 - Proses vektor ini.

• Langkah 5 - Susun semula.

• Langkah 6 − Tolak mereka ke belakang dari vektor ke pepenjuru kiri.

• Langkah 7 - Alih keluar semua vektor yang menjadikan set kosong.

• Langkah 8 - Mulakan jenis baru semula.

• Langkah 9 - Ulang semua langkah sekali lagi.

• Langkah 10 - Langkah demi langkah untuk melengkapkan semua garisan pepenjuru kiri.

• Langkah 11 - Matikan proses.

Sintaks untuk mengisih tatasusunan 2D pada pepenjuru kiri

Di sini kami mempunyai beberapa sintaks khusus untuk mengambil beberapa tatasusunan 2D di sepanjang pepenjuru kiri seperti yang ditunjukkan di bawah:

A. keluarkanSemua():

Sintaks:

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

B. Collections.sort()：

Sintaks:

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

C. tambah():

Sintaks:

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

D. dapatkan():

Sintaks:

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

Dalam sintaks tertentu ini, kami cuba mengisih beberapa tatasusunan 2D di sepanjang pepenjuru kiri.

Kaedah untuk mengisih tatasusunan 2D ke kiri secara menyerong

• Kaedah 1 - Program Java untuk mengisih tatasusunan 2D mengikut pepenjuru kiri

• Kaedah 2 - Program Java untuk mengisih matriks 2D dalam susunan menurun pepenjuru

• Kaedah 3 - Program Java untuk mengisih matriks 2D secara menyerong dan mendapatkan jumlahnya

Program Java: Isih tatasusunan 2D mengikut pepenjuru kiri

Dalam kod Java ini kami telah cuba menunjukkan cara mengisih tatasusunan 2D merentasi pepenjuru kiri secara umum.

Terjemahan bahasa Cina bagi

Contoh 1

ialah:

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

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 

Program Java untuk mengisih matriks 2D dalam susunan menurun pepenjuru

Dalam kod Java ini, kami cuba menunjukkan cara mengisih matriks tatasusunan 2D di sepanjang pepenjuru kiri secara menurun.

Terjemahan bahasa Cina bagi

Contoh 2

ialah:

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

	}
}

Output

10 6 3 
8 9 2 
7 4 5

Atur cara Java untuk mengisih matriks 2D secara menyerong dan mendapatkan jumlahnya

Dalam kod Java ini, kami cuba menunjukkan cara mengisih matriks tatasusunan 2D di sepanjang pepenjuru kiri dan mendapatkan jumlahnya.

Contoh 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

Kesimpulan

Dalam artikel ini, kami telah membincangkan secara terperinci masalah menyusun tatasusunan 2D. Hari ini kami menggunakan pelbagai kaedah pengisihan berdasarkan tatabahasa dan algoritma di atas untuk menyelesaikan masalah ini. Mudah-mudahan, melalui artikel ini, anda akan mendapat pemahaman yang luas tentang masalah cara menyusun tatasusunan 2D dengan menggunakan pepenjuru kiri dalam persekitaran Java.

Atas ialah kandungan terperinci Program Java untuk mengisih tatasusunan 2D ke kiri secara menyerong. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!