Java 程序跨列对二维数组进行排序

javaobject oriented programmingprogramming更新于 2024/3/27 21:00:17

在数据结构领域,向量是特定对象的可增长类数组。向量类属于与集合完全兼容的遗留类。在 java.util 包中,List 接口可以使用此处列出的所有方法。这里的初始容量为 10,一般方法是:

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

compare() 方法接受两个参数,然后使用 Java 环境逻辑相互比较。

在今天的这篇文章中,我们将了解跨列设置的 2D 数组的排序过程。

跨列对 2D 数组进行排序的算法:-

以下是跨列对 2D 数组进行排序的具体算法。

  • 步骤 1 - 开始。

  • 步骤 2 - 逐一遍历所有列。

  • 步骤 3 - 在向量中的该列上添加元素。

  • 步骤 4 - 处理这些向量。

  • 步骤 5 - 再次对它们进行排序。

  • 步骤 6 - 将它们从向量推回到列。

  • 步骤 7 − 删除所有向量以使集合为空。

  • 步骤 8 − 重新开始排序。

  • 步骤 9 − 再次重复所有步骤。

  • 步骤 10 − 像这样一步一步完成所有列。

  • 步骤 11 − 终止该过程

跨列对 2D 数组进行排序的语法

这里我们有一些特殊的语法来跨列拍摄一些 2D 数组,如下所示:

A. removeAll():

语法:

Vector.removeAll(Vectors As Value)
用于从向量中删除所有元素。

B. Collections.sort():

语法:

Collections.sort(Vectors As Value)
此方法用于对过程中的向量进行排序。

C. add():

语法:

Vector.add(Value 作为整数值)
用于在向量中添加一些元素。

D. get():

语法:

Vector.get(3);
此方法用于将向量元素存储在特定索引处。

在这里,在这些特定的语法中,我们尝试对一些跨列的二维数组进行排序。

跨列对二维数组进行排序的方法

  • 方法 1 - Java 程序对跨列的二维数组进行排序

  • 方法 2 - Java 代码使用函数 Arrays.sort 对二维矩阵进行排序

  • 方法 3 - Java 程序使用气泡图对二维数组进行排序,就像对大小为 n * m 的一维数组进行排序一样

  • 方法 4 - Java 程序根据 3 列进行排序,比较这些值并按升序更改二维数组的特定顺序

Java 程序对跨列的二维数组进行排序

在此 Java 代码中,我们尝试展示如何排序以一般方式跨列显示二维数组。

示例 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 = { { 7, 16, 10, 97, 1 },
         { 3, 8, 2, 9, 14 },
         { 5, 1, 0, 5, 2 },
         { 4, 2, 6, 0, 1 } };
      System.out.println("Matrix without sorting here ----> \n");
      for (int i = 0; i < 4; 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++) {
         for (int j = 0; j < 4; j++) {
            v.add(arr[j][i]);
      	}
      	Collections.sort(v);

      	for (int j = 0; j < 4; j++) {
           arr[j][i] = v.get(j);
      	}
      	v.removeAll(v);
      }

      System.out.println("Matrix after sorting is ----> \n");

      for (int i = 0; i < 4; i++) {
         for (int j = 0; j < 5; j++) {
            System.out.print(arr[i][j] + " ");
      }

      System.out.println();
      }
   }
}

输出

Matrix without sorting here ----> 

7 16 10 97 1 
3 8 2 9 14 
5 1 0 5 2 
4 2 6 0 1 
Matrix after sorting is ----> 

3 1 0 0 1 
4 2 2 5 1 
5 8 6 9 2 
7 16 10 97 14 

使用 Arrays.sort 函数对二维矩阵进行排序的 Java 代码

在此 Java 代码中,我们尝试展示如何使用 Arrays.sort 方法以一般方式对二维数组的各列进行排序。

示例 2

import java.util.*;
public class sort2DMatrixbycolumn2022 {
   public static void sortbyColumn(int arr[][], int col){
      Arrays.sort(arr, new Comparator<int[]>() {
      	
         @Override      	
         public int compare(final int[] entry1, final int[] entry2) {
            if (entry1[col] > entry2[col])
               return 1;
      	    else
               return -1;
         }
      }); 
   }
   public static void main(String args[]){
      int matrix[][] = { { 39, 27, 11, 42 },
         { 10, 93, 91, 90 },
         { 54, 78, 56, 89 },
         { 24, 64, 20, 65 } };
      int col = 3;
      sortbyColumn(matrix, col - 1);

      for (int i = 0; i < matrix.length; i++) {
      	for (int j = 0; j < matrix[i].length; j++)
           System.out.print(matrix[i][j] + " ");
      	System.out.println();
      }
	}
}

输出

39 27 11 42 
24 64 20 65 
54 78 56 89 
10 93 91 90

Java 程序使用冒泡排序对大小为 n * m 的一维数组中的二维数组进行排序

在此 Java 代码中,我们尝试展示如何以一般方式跨列对大小为 n * m 的一维数组中的二维数组进行排序。

示例 3

package jex;
import java.util.*;
public class demo {
   public static void sort(int arr[][]) {
      int i, j, temp;
      int n=arr.length;
      int m=arr[0].length;
      for (i = 0; i < n * m - 1; ++i) {
         for (j = 0; j < n * m - 1 - i; ++j) {
            if (arr[j / m][j % m] > arr[(j + 1) / m][(j + 1) % m]) {
               temp = arr[(j + 1) / m][(j + 1) % m];
               arr[(j + 1) / m][(j + 1) % m] = arr[j / m][j % m];
               arr[j / m][j % m] = temp;
            }
         }
      }
   }
   public static void print(int arr[][]) {
      int i, j;
      int n=arr.length;
      int m=arr[0].length;
      for (i = 0; i < n; ++i) {
         for (j = 0; j < m; ++j) {
            System.out.print(arr[i][j]+" ");
         }
         System.out.println();
      }
   }
   public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      int[][] arr={ { 5, 12, 17, 12, 23},
         { 1, 2, 4, 6, 8},
         {21, 14, 7, 19, 27},
         { 3, 18, 9, 15, 25}
      };
      System.out.println("Array Before Sorting is here ---->: ");
      print(arr);
      sort(arr);
      System.out.println("Array After Sorting is here ----> : ");
      print(arr);
   }
}

输出

Array Before Sorting is here ---->: 
5 12 17 12 23 
1 2 4 6 8 
21 14 7 19 27 
3 18 9 15 25 
Array After Sorting is here ----> : 
1 2 3 4 5 
6 7 8 9 12 
12 14 15 17 18 
19 21 23 25 27

Java 程序根据 3 列进行排序,比较这些值并按升序更改 2D 数组的特定顺序

在此 Java 代码中,我们尝试展示如何根据 3 列进行排序,比较这些值并按升序更改 2D 数组的特定顺序。

示例 4

import java.util.Arrays;
import java.util.Comparator;

public class Sort2DArray {
   public static void main(String args[]) {
      int[][] multi = new int [][]{
         {4, 9, 8},
         {7, 5, 2},
         {3, 0, 6},

      };
      for(int i = 0; i< multi.length; i++) {
         for (int j = 0; j < multi[i].length; j++)
         System.out.print(multi[i][j] + " ");
         System.out.println();

      }
      Sort2DArrayBasedOnColumnNumber(multi,3);
      System.out.println("after sorting we get some value ---->");
      for(int i = 0; i< multi.length; i++) {
         for (int j = 0; j < multi[i].length; j++)
         System.out.print(multi[i][j] + " ");
         System.out.println();

      }
   }
    public static  void Sort2DArrayBasedOnColumnNumber (int[][] array, final int columnNumber){
      Arrays.sort(array, new Comparator<int[]>() {
         @Override
         public int compare(int[] first, int[] second) {
            if(first[columnNumber-1] > second[columnNumber-1]) return 1;
            else return -1;
         }
      });
   }
}

输出

4 9 8 
7 5 2 
3 0 6 
after sorting we get some value ---->
7 5 2 
3 0 6 
4 9 8 

结论

通过以上讨论,我们详细了解了二维数组排序问题。今天,我们在这里使用了各种排序方法,通过上述语法和算法解决了这个问题。希望通过本文,您已经对如何使用 Java 环境对二维数组问题进行排序有了广泛的了解。


相关文章


有用资源