Java 对二维数组按行排序

在数据结构中，排序是指根据问题或给定的运算符重新排列给定的元素列表或某个数组。这个运算符决定了元素的新顺序。数组是一组特定元素的集合，可以是占据相邻内存位置的任何东西。在这里，我们将相同类型的多个元素存储在一起。排序帮助我们重新排列这些元素。例如，15、8、12、28是未排序数组的元素，排序后，28、15、12、8成为一个降序排列的数组。

本文将演示如何使用Java程序对二维数组按行排序。我们将使用三种不同的方法来解决问题。首先，我们将使用vector()方法，其次是库函数Array.sort，最后我们将使用冒泡排序。

vector()方法的步骤

步骤 1 - 导入所有所需的库。
步骤 2 - 在排序之前打印和显示矩阵。
步骤 3 - 创建一个Vector类的对象。
步骤 4 - 将行的元素添加到Vector中。
步骤 5 - 对Vector进行排序。
步骤 6 - 从Vector中删除元素。
步骤 7 - 在排序之后打印和显示矩阵。
步骤 8 - 使用循环重复，直到所有行都排序完毕。
步骤 9 - 完成。

语法

Vector v = new Vector<>();

以下程序中使用的功能：

removeAll() − 这个函数用来从向量中移除所有元素，我们为了排序而把它们存储起来。
Vector.get(element) − get() 方法用来获取向量中存储在特定位置的元素。
add() 函数将元素添加到向量中。
Collection.sort() − 这个方法用来对向量进行排序。

使用库函数arrays.sort的算法

步骤1 − 导入所有所需的库。
步骤2 − 逐行对每个行进行排序。
步骤3 − 使用函数Arrays.sort()。
步骤4 − 打印并显示已排序的矩阵。

语法

Array.sort(arr[i]);

冒泡排序算法

步骤1 − 导入所需的所有库。
步骤2 − 使用循环遍历矩阵的行和列。
步骤3 − 使用另一个循环进行比较和交换。
步骤4 − 交换元素。
步骤5 − 打印排序后的矩阵。

语法

begin BubbleSort(arr)
for all array elements
   if arr[i] > arr[i+])
      swap(arr[i], arr[i+1]
   end if
end for
return arr
end BubbleSort

方法

使用Vector()函数
使用Arrays.sort()函数
使用冒泡排序(Bubble sort)

方法1：Vector()

示例

import java.io.*;
import java.util.*;

public class WC {
   public static void main(String[] args) throws java.lang.Exception {
      int[][] arr = {
         {1, 3, 8, 5, 9},
         {5, 3, 1, 7, 4},
         {0, 5, 9, 2, 6},
         {4, 6, 3, 1, 0},
         {3, 5, 8, 9, 2}
      };

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

      List<Integer> space = new ArrayList<>();

      for (int i = 0; i < 5; i++) {
         for (int j = 0; j < 5; j++) {
            space.add(arr[i][j]);
         }

         Collections.sort(space);

         for (int j = 0; j < 5; j++) {
            arr[i][j] = space.get(j);
         }

         space.clear();
      }

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

输出

Array without sorting
1 3 8 5 9 
5 3 1 7 4 
0 5 9 2 6 
4 6 3 1 0 
3 5 8 9 2 
Array after sorting
1 3 5 8 9 
1 3 4 5 7 
0 2 5 6 9 
0 1 3 4 6 
2 3 5 8 9

上面是通过vector()方法输出的，我们首先打印了未排序的矩阵，然后在程序执行后显示了排序后的矩阵。

方法2: Arrays.sort()

示例

import java.io.*;
import java.util.Arrays;

public class ArraySort {

   static int sortrowWise ( int arr [][]) {

      for (int i =0; i< arr.length; i++)
      Arrays.sort(arr[i]);

      for (int i =0; i < arr.length;i++) {

         for( int j=0; j < arr[i].length; j++)

         System.out.print(arr[i][j] + "");
         System.out.println();
      }
      return 0;
   }
   public static void main(String args[]){
      int arr[][] = {  { 9,2,6,4,5},
                        { 8,3,7,0,2},
                        { 5,3,8,1,2},
                        { 3,5,7,1,0}
                     };
      sortrowWise(arr);

   }
}

输出

上面是使用Arrays.sort（）库方法排序后的排序矩阵的输出。

方法3：冒泡排序（Bubble Sort）

示例

import java.io.*;

public class BubbleSort {
   static int sortRowWise (int arr[][]) {

      for (int i= 0; i < arr.length; i++) {

         for (int j=0; j< arr[i].length; j++) {

            for (int k=0; k<arr[i].length - j -1; k++ ) {
               if (arr[i][k]> arr[i] [k+1]) {
                  int t = arr[i][k];
                  arr[i][k] = arr[i][k + 1];
                  arr[i][k + 1] = t;
               }
            }
         }
      }
      for (int i=0; i< arr.length; i++) {
         for (int j =0; j< arr [i].length; j++)

            System.out.print(arr[i][j] + "");
            System.out.println();
      }
      return 0;
   }
   public static void main (String arg[]){

      int arr[][] = { { 0,3,6,9,4},
                        { 7,5,3,8,1},
                        { 2,5,3,9,0},
                        { 1,7,4,0,2} };
      sortRowWise(arr);                            
   }
}