精华内容
下载资源
问答
  • Java | 二维数组排序

    2021-09-15 10:35:22
    借助Arrays的方法对二维数组进行排序。 参考思路: 先把二维数组使用System.arraycopy进行数组复制到一个一维数组 然后使用sort进行排序 最后再复制回到二维数组。 代码示例 package Test; import java.lang....

    题目要求

    首先定义一个5X8的二维数组,然后使用随机数填充满。
    借助Arrays的方法对二维数组进行排序。

    参考思路:

    先把二维数组使用System.arraycopy进行数组复制到一个一维数组
    然后使用sort进行排序
    最后再复制回到二维数组。

    代码示例

    package Test;
    import java.lang.Math;
    import java.util.Arrays;
    public class ArraysClassLearning {
    	public static void main(String[] args) {
    		int [][] a = new int[5][8];
    		int [] b = new int[40];
    		for(int i=0;i<5;i++) {
    			for(int j=0;j<8;j++) {
    				a[i][j] = (int)(Math.random()*100); 
    //				System.out.print(a[i][j]+" ");
    			}
    			System.arraycopy(a[i], 0, b, i*8, 8);
    		}
    		System.out.println("二维数组为:");
    		for(int[] i:a) {
    			for(int j:i) {
    				System.out.print(j+" ");
    			}
    			System.out.println();
    		}
    		Arrays.sort(b);
    		for(int i:b) {
    			System.out.print(i+" ");
    		}
    		System.out.println();
    		for(int i=0;i<5;i++) {
    			a[i] = Arrays.copyOfRange(b, i*8, i*8+8);
    		}
    		System.out.println("排序后二维数组为:");
    		for(int[] i:a) {
    			for(int j:i) {
    				System.out.print(j+" ");
    			}
    			System.out.println();
    		}
    	}
    }
    

    展开全文
  • Java二维数组排序

    万次阅读 2019-06-29 15:46:12
    Java二维数组排序

    Java二维数组排序

    Java二维数组排序

    关于Java二维数组的排序方法之一是把二维数组放进一维数组然后试用版Arrays.sort();进行排序,排序结束后再把一维数组内容重新写入二维数组内,代码实现如下:

    为了方便,我在这里使用了随机数生成方法Math.random()进行随机数生成,依次写入二维数组内:

    import java.util.*;
    public class P11{
    	public static void main(String[] args){
    		int[][] arr=new int[5][5];
    		for(int i=0;i<arr.length;i++){
    			for (int j=0;j<arr[i].length;j++){//生成随机数【100-1000】
    				arr[i][j]=(int)(Math.random()*(1000-100+1)+100);
    			}
    		}
    		for(int i=0;i<arr.length;i++){
    			System.out.println(Arrays.toString(arr[i]));
    		}
    		System.out.println();
    		for(int i=0;i<arr.length;i++){
    			Arrays.sort(arr[i]);
    		}
    		for(int i=0;i<arr.length;i++){
    			System.out.println(Arrays.toString(arr[i]));
    		}
    		int[] temp=new int[25];
    		int k=0;
    		for(int i=0;i<arr.length;i++){
    			for(int j=0;j<arr[i].length;j++){
    				temp[k]=arr[i][j];
    				k++;
    			}
    		}
    		System.out.println();
    		for(int x:temp){
    			System.out.print(x+" ");
    		}
    		Arrays.sort(temp);
    		System.out.println();
    		for(int x:temp){
    			System.out.print(x+" ");
    		}
    		k=-1;
    		for(int i=0;i<arr.length;i++){
    			for(int j=0;j<arr[i].length;j++){
    				k++;
    				arr[i][j]=temp[k];
    			}
    		}
    		System.out.println();
    		System.out.println();
    		for(int i=0;i<arr.length;i++){
    			System.out.println(Arrays.toString(arr[i]));
    		}
    	}
    }
    

    因为使用了随机数生成的数组内容,所以每次运行数组内容都不尽相同,本次运行结果如下:

    排序结果

    展开全文
  • Java完成二维数组排序

    千次阅读 2019-04-11 00:17:43
    二维数组中(每个一维数组的长度相同),按照如下规则排序:每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序 public class HashMapTest { public static void main(String[] args) { ...

    二维数组中(每个一维数组的长度相同),按照如下规则排序:每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序

    public class HashMapTest {
    	public static void main(String[] args) {
    		HashMapTest h = new HashMapTest();
    		int b[][] = new int[][]{{9,2,1},{4,5,5},{6,8,7},{2,5,8}};
    		h.rank(b);
    	}
    	
    	/**
    	 * 二维数组排序,从左到右,从上到下均增加
    	 * @description TODO
    	 * @param a
    	 * @return
    	 * @return int[][]
    	 * @throws
    	 */
    	public int[][] rank(int[][] a){
    		int h = a.length;
    		int w = a[0].length;
    		System.out.println("二维数组行数为:"+h+",列数为:"+w);
    		System.out.println("二维数组排序前:");
    		printArray(a);
    		System.out.println("---------开始排序-------");
    		
    		//System.out.println(result[0]+","+result[1]+","+result[2]);
    		//最小的放在第一个位置,依次往后排
    		for(int x=0;x<a.length;x++){
    			for(int y=0;y<a[x].length;y++){
    				int[] result = minArray(a, x, y);
    				a[result[0]][result[1]] = a[x][y];
    				a[x][y]=result[2];
    				printArray(a);
    				System.out.println("------------");
    			}
    		}
    		return a;
    	}
    	
    	//返回二维数组位置坐标和该位置后(包含)的最小的值的坐标
    	//x为第x行,y为第y列,且都从0开始
    	//result[0]:最小值坐标的行
    	//result[1]:最小值坐标的列
    	//result[2]:最小值
    	public int[] minArray(int[][] a, int x, int y){
    		int[] result = new int[3];
    		int Time = 1;
    		
    		int r0 = x;
    		int r1 = y;
    		//此位置后最小值
    		int mid = a[x][y];
    		//从第x行开始
    		for(int i=x;i<a.length;i++){
    			if (Time==1){
    				//第一次从第y列开始
    				//System.out.println("第x行从y列开始:");
    				for(int j=y;j<a[i].length;j++){
    					if(a[i][j]<mid){
    						mid = a[i][j];
    						r0 = i;
    						r1 = j;
    						//System.out.print(a[i][j]+",");
    					}
    				}
    				Time--;
    			}else{
    				//后面的从第0列开始
    				for(int j=0;j<a[i].length;j++){
    					if(a[i][j]<mid){
    						mid = a[i][j];
    						r0 = i;
    						r1 = j;
    						//System.out.print(a[i][j]+",");
    					}
    				}
    			}
    		}
    		result[0]=r0;
    		result[1]=r1;
    		result[2]=mid;
    		return result;
    		
    	}
    //打印二维数组
    	public void printArray(int[][] a){
    		for(int i=0;i<a.length;i++){
    			for(int j=0;j<a[i].length;j++){
    				System.out.print(a[i][j]+",");
    			}
    			System.out.println("");
    		}
    	}
    
    展开全文
  • 运用java 实现二维数组排序 (排序要求为‘基于第一个元素排序’组合不变) 三种排序方法分别为: 选择排序,插入排序和排列排序; //选择排序 public class Sort { public static void main(String[] args) { int...

    运用java 实现二维数组排序

    (排序要求为‘基于第一个元素排序’组合不变)
    三种排序方法分别为:
    选择排序,插入排序和排列排序;

    //选择排序
    public class Sort {
        public static void main(String[] args) {
            int[][] testB = { { 71, 2 }, { 64, 8 }, { 31, 56 }, { 98, 1 }, { 3, 6 }, { 59, 837 }, { 49, 58 }, { 61, 8 } };
            System.out.println("交换之前:");
            for (int i = 0; i < testB.length; i++) {
                for (int j = 0; j < testB[i].length; j++) {
                    System.out.print(testB[i][j] + " ");
                }
                System.out.println();
            }
            //选择排序的优化
            for(int i = 0; i < testB.length - 1; i++) {// 做第i趟排序
                int k = i;
                for(int j = k + 1; j < testB.length; j++){// 选最小的记录
                    if(testB[j][0] < testB[k][0]){
                        k = j; //记下目前找到的最小值所在的位置
                    }
                }
                //在内层循环结束,也就是找到本轮循环的最小的数以后,再进行交换
                if(i != k){  //交换a[i]和a[k]
                    int temp = testB[i][0];
                    testB[i][0] = testB[k][0];
                    testB[k][0] = temp;
                    int temp1 =testB[i][1];
                    testB[i][1] = testB[k][1];
                    testB[k][1] = temp1;
                }
    
            }
            System.out.println();
            System.out.println("交换后:");
            for (int i = 0; i < testB.length; i++) {
                for (int j = 0; j < testB[i].length; j++) {
                    System.out.print(testB[i][j] + " ");
                }
                System.out.println();
            }
    
    }}
    

    插入排序:是指在待排序的元素中,假设前面n-1(其中n>=2)个数已经是排好顺序的,现将第n个数插到前面已经排好的序列中,然后找到合适自己的位置,使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入,直到整个序列排为有序的过程

    import java.util.Arrays;
    //直接插入排序
    public class Sort {
        public static void insertSort(int[][] array) {
            int j = 0;
            for (int i = 1; i < 8; i++) {
                int tmp = array[i][0];
                int temp1=array[i][1];
                for (j = i - 1; j >= 0; j--) {
    
                    if (tmp < array[j][0]) {
                        array[j + 1][0] = array[j][0];
                        array[j+1][1]=array[j][1];
                    } else {
                        break;
                    }
                }
                array[j + 1][0] = tmp;
                array[j+1][1]=temp1;
            }
        }
    
        public static void main(String[] args) {
            int[][] testB = { { 71, 2 }, { 64, 8 }, { 31, 56 }, { 98, 1 }, { 3, 6 }, { 59, 837 }, { 49, 58 }, { 61, 8 } };
            System.out.println("排序后为:");
            insertSort(testB);
            for (int i = 0; i < testB.length; i++) {
                for (int j = 0; j < testB[i].length; j++) {
                    System.out.print(testB[i][j] + " ");
                }
                System.out.println();
            }
        }
    }
    

    排列排序(rank sort):

    public class Rank_Sort {
        public static void main(String[] args) {    
            int[][] testB = { { 71, 2 }, { 64, 8 }, { 31, 56 }, { 98, 1 }, { 3, 6 }, { 59, 837 }, { 49, 58 }, { 61, 8 } };
                    
            //打印初始二维数组
                    System.out.println("排序前:");
            for (int i = 0; i < testB.length; i++) {
                for (int j = 0; j < testB[j].length; j++) {
                    System.out.print(testB[i][j] + " ");
                }
                System.out.println();
            }
    
            testB = RankSortArray(testB);
    
            System.out.println("排序后:");
            // print the finished two-dimentional array;
            for (int i = 0; i < testB.length; i++) {
                for (int j = 0; j < testB[j].length; j++) {
                    System.out.print(testB[i][j] + " ");
                }
                System.out.println();
            }
    
        }
        
        public static int[][] RankSortArray(int[][] a) {
            int[][] arr = new int[a.length][a[0].length];//定义了一个新数组作为排序数组
            for (int i = 0; i < a.length; i++) {
                int index = 0; //定义了一个索引变量,它是new中整数的第一个索引
    
    //阵列
    
               /*
    
    *查找小于[i]的整数,其中的个数是第一个整数
    
    *新数组中[i][]的索引
    
    */
                for (int j = 0; j < a.length; j++) {
                    if (a[i][0] > a[j][0]) {
                        index++;
                    }
                }
    
                for (int k = 0; k < 2; k++) {
                    arr[index][k] = a[i][k];
                }
            }
    
           /*
    
    *为了避免有许多相同的第一个值,我们用一种
    
    方法,主要思想是:1:如果有一个二维数组的第一个值
    
    为0(从arr[][]的第二个值开始),arr[i][0]必须等于
    
    arr[i-1][0];2:我们遍历a[][],找到a[][0]==arr[i][0],让
    
    arr[i][1]=a[][1];3:我们创建一个新的变量数来计算
    
    乘以a[][0]==arr[i][0]。
    
    */
            int number = 0;
            for (int i = 1; i < arr.length; i++) {
                if (arr[i][0] == 0) {
                    arr[i][0] = arr[i - 1][0];
                    if (number != 0) {
                        number = 1 - i;
                    }
                    for (int j = a.length - 1; j >= 0; j--) {
                        if (arr[i][0] == a[j][0]) {
                            number++;
                            if (number > 1) {
                                arr[i][1] = a[j][1];
                                break;
                            }
                        }
                    }
    
                }
            }
    
            return arr;
        }
    }
    
    展开全文
  • //借助Arrays的方法对二维数组进行排序。 //参考思路: //先把二维数组使用System.arraycopy进行数组复制到一个一维数组 //然后使用sort进行排序 //最后再复制回到二维数组。 import java.util.Arrays; public ...
  • Java二维数组排序

    2021-03-10 19:15:38
    排序规则:首先按照每个一维数组第一个元素进行升序排序,若第一个元素相等,则按照第个元素进行升序排序。 原代码 Arrays.sort(a, new Comparator<int[]>() { @Override public int compare(int[] o1, int...
  • 假设有个二维数组: int[][] arr = {{1,2},{3,4},{5,6}}; 需要按一定规则调整,其中一维数组的顺序,比如规则为按一维数组的首元素从小到大排。 数组排序可以使用Arrays.sort(),自定义规则的话需要自己定义...
  • Java如何给二维数组排序

    千次阅读 2020-08-17 10:11:50
    首先,因为是对给定的二维数组排序 那么自然就对应Java官方库中的Arrays工具类 即:Arrays.sort(T[] a, Comparator<? super T> c) 如二维整型数组 int[][] 2darr = new int[10][10]; 则有: (下面写法是按照...
  • java二维数组排序

    2020-12-31 11:12:39
    维数组排序很简单,调用Arrays.sort(array)就可以直接进行排序。二维数组稍微复杂一些。 二维数组根据第一列排序: int[][] ts_id = new int[][] {{1,2},{99,0},{876,9},{3,100}}; Arrays.sort(ts_.
  • JAVA 二维数组 排序

    2021-05-24 00:17:48
    二维数组 int[][] 数组名=new int[2][2]; import java.util.Scanner; public class Day6T1 { public static void main(String[] args) { int[][] scores = new int[2][]; Scanner input = new Scanner(System...
  • java二维数组排序的几种方法

    万次阅读 2016-11-29 22:36:12
    // 二维数组全部排序 public void dAM2() { int[][] a = { { 12, 26, 89, 78, 45, 65, 36 }, { 2, 6, 90, 34, 16, 27, 5 }, { 13, 3, 4, 29, 33, 37, 17 }, { 1, 9, 19, 49, 57, 22, 11 }, ...
  • Java 二维数组排序

    2020-05-19 08:58:30
    //定义一个二维数组,其中所包含的一维数组具有两个元素 对于一个已定义的二位数组a进行如下规则排序,首先按照每一个对应的一维数组第一个元素进行升序排序(即a[][0]),若第一个元素相等,则按照第二个元素进行升序...
  • java笔记数组一维数组使用增强for循环遍历一维素组经典冒泡排序二维数组Arrays类的应用将所有元素赋相同的值查询元素在数组中的下标 数组 一维数组 **定义:**数组是用来存储一组相同类型数据的数据结构 注意:数组...
  • java 二维数组排序

    2021-04-18 17:23:49
    排序规则: 先按数组的第一个元素进行升序排序,若第一个元素相等,则按照第个元素进行升序排序。 使用API:Arrays.sort()(T[] a, Comparator<? super T> c),该API根据给定的比较器(设定排序方式)对指定的...
  • //定义一个二维数组,其中所包含的一维数组具有两个元素 对于一个已定义的二位数组a经行如下规则排序,首先按照每一个对应的一维数组第一个元素进行升序排序(即a[][0]),若第一个元素相等,则按照第二个元素进行升序...
  • 利用冒泡排序对字符串二维数组进行排序 package lan; public class array { public static void main(String[] args) { String arr[][]= {{"青年节","5.4"}, {"教师节","9.10"}, {"女生节","3.9"}, {"妇女...
  • Java实现二维数组排序(先行再列)

    千次阅读 2017-11-17 18:22:09
    先按行排序,然后按列排序: import java.util.Scanner; public class Text { public static void main(String[] args) { //int[][] array= {{4,2},{1,7},{4,5},{1,2},{1,1},{4,1}}; int[][] array= {{1,2,2,...
  • ◆◆◆一、理解一维数组的定义和应用,了解二维数组和控件数组;1、数组的概念:数组并不是一种数据类型,而是一组相同类型数据的集合。用一个统一的名字(数组名)代表逻辑上相关的一批数据,每个元素用下标变量来...
  • ***解题思路***将二维数组抽调成一维数组,再又一维数组还原成二维数组 import java.util.Arrays;//引入Arrays类 public class test {public static void main(String[] args) { int array[][]={{11,4,2},{19,21,1}...
  • *8.16(对二维数组排序)编写一个方法,使用下面的方法头对二维数组排序。这个方法首先按行排序,然后按列排序题目题目描述破题代码运行实例 题目 题目描述 *8.16(对二维数组排序)编写一个方法,使用下面的方法头...
  • 使用冒泡排序实现的java语言编写的关于二维数组排序,实现了行、列的排序输出。
  • 文章目录方法一:重写Arrays.sort方法方法:...待排序数组形式int[][] array = new int[n][2],其中n为任意整数。 import java.util.Arrays; public class Sort { public static int[][] mySort(int[][]...
  • import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Comparator; public class test { static class one{ private int x; private int y; private int

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,632
精华内容 15,052
关键字:

java给二维数组排序

java 订阅