精华内容
下载资源
问答
  • //先把二维数组使用System.arraycopy进行数组复制到一个一维数组 //然后使用sort进行排序 //最后再复制回到二维数组。 import java.util.Arrays; public class array { public static void main(String[] args) {...
    package cn.sxt.Test;
    //首先定义一个5X8的二维数组,然后使用随机数填充满。
    //借助Arrays的方法对二维数组进行排序。
    //参考思路:
    //先把二维数组使用System.arraycopy进行数组复制到一个一维数组
    //然后使用sort进行排序
    //最后再复制回到二维数组。
    
    import java.util.Arrays;
    
    public class array {
        public static void main(String[] args) {
        /*
        首先定义一个一维数组长度40和二维数组5*8
        */
        	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);	
    		}	
    	}
    	/*
    	增强for循环遍历二维数组a。array.toString()方法查看
    	*/
          for(int[] temp : a)
          {
        	  System.out.println(Arrays.toString(temp));
          }
          /*
          二维数组a 5行8列,用for循环把各行的元素复制到把数组中
          */
          for (int i = 0; i < 5; i++) {
          /*复制数组: System.arraycopy(源数组, 原数组开始复制下标, 目标数组, 目标数组粘贴下标, 复制长度)*/
        	  System.arraycopy(a[i], 0, b, i * 8, 8);
    	}
          System.out.println(Arrays.toString(b));
          //对一维数组b排序
          Arrays.sort(b);
          System.out.println(Arrays.toString(b));
          //把排序好的一位数组重新复制回二维数组中
          for(int i = 0; i < 5; i++)
          {
        	  System.arraycopy(b, i * 8, a[i], 0, 8);
          }
          //打印排序好的二维数组
          for(int[] temp : a)
          {
        	  System.out.println(Arrays.toString(temp));
          }  
        }
    }
    
    展开全文
  • 维数组排序Java

    2021-01-26 13:31:27
    java的集合类提供排序方法,可以根据自定义的方法对集合进行排序。 public static void main(String[] args) { int[][] res = {{1,2},{3,4},{2,1},{5,6}}; Arrays.sort(res, new Comparator<int[]>(){ ...

    java的集合类提供一个排序方法,可以根据自定义的方法对集合进行排序。

    public static void main(String[] args) {
            int[][] res = {{1,2},{3,4},{2,1},{5,6}};
    
            Arrays.sort(res, new Comparator<int[]>(){
    
                @Override
                public int compare(int[] o1, int[] o2) {
                    if((o1[1]+o1[0]) > (o2[0]+o2[1])){
                        return 1;
                    }
                    return -1;
                }
            });
            Arrays.asList(res).forEach(s->System.out.println(s[0]+","+s[1]));
    
    //        Arrays.stream(res).forEach(System.out::println);
        }
    

    注意上述compare方法返回值需要一正一负,也可以直接返回两数之差。

    展开全文
  • java 一维数组排序

    千次阅读 2016-11-21 23:59:57
    介绍几种简单的使用java一维数组进行排序(本人菜鸟,如有错误还望大神多多指出!): // 冒泡排序 public void bubble_sort() { int arr[] = { 1, 23, 34, 54, 2, 3, 12, 9 }; for (int i = 0; i ; i++) { ...

    介绍几种简单的使用java对一维数组进行排序(本人菜鸟,如有错误还望大神多多指出!):

    // 冒泡排序
    	public void bubble_sort() {
    		int arr[] = { 1, 23, 34, 54, 2, 3, 12, 9 };
    		for (int i = 0; i < arr.length - 1; i++) {
    			for (int j = 0; j < arr.length - 1 - i; j++) {
    				// 用<就是从大到小,用>就是由小到大
    				if (arr[j] > arr[j + 1]) {
    					int t = arr[j];
    					arr[j] = arr[j + 1];
    					arr[j + 1] = t;
    				}
    			}
    		}
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i] + "\t");
    		}
    	}
    
    	// 选择排序
    	public void selection_sort() {
    		int arr[] = { 1, 23, 34, 54, 2, 3, 12, 9 };
    		for (int i = 0; i < arr.length - 1; i++) {
    			for (int j = i + 1; j < arr.length; j++) {
    				// 用<就是从大到小,用>就是由小到大
    				if (arr[i] > arr[j]) {
    					int t = arr[i];
    					arr[i] = arr[j];
    					arr[j] = t;
    				}
    			}
    		}
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i] + "\t");
    		}
    	}
    
    	// 查找算法(从数组里查找12这个数);
    	public void lookup_algorithm() {
    		int arr[] = { 1, 23, 34, 54, 2, 3, 12, 9 };
    		boolean flag = false;
    		int index = 12;
    		for (int i = 0; i < arr.length; i++) {
    			if (index == arr[i]) {
    				flag = true;
    				break;
    			}
    		}
    		if (flag) {
    			System.out.println("找到了:" + index);
    		} else {
    			System.out.println("未找到");
    		}
    	}
    
    	// 插入算法(插入5)
    	public void insertion_algorithm() {
    		int arr[] = { 1, 23, 34, 54, 2, 3, 12, 9 };
    		int num = 5;
    		arr[arr.length - 1] = num; // 给数组最后一个坐标赋值
    		for (int i = 0; i < arr.length - 1; i++) {
    			for (int j = i + 1; j < arr.length; j++) {
    				if (arr[i] > arr[j]) {
    					int t = arr[i];
    					arr[i] = arr[j];
    					arr[j] = t;
    				}
    			}
    		}
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i] + "\t");
    		}
    	}
    
    	// 数组复制
    	public void Copy_Ary() {
    		int arrOld[] = { 1, 32, 32, 4234, 4334, 1223, 1 };
    		int arrNew[] = new int[arrOld.length];
    		for (int i = 0; i < arrOld.length; i++) {
    			arrNew[i] = arrOld[i];
    		}
    		for (int i = 0; i < arrNew.length; i++) {
    			System.out.print(arrNew[i] + "\t");
    		}
    	}
    
    	/**
    	 * 直接插入排序 基本思想:在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排好顺序的,
    	 * 现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。
    	 */
    	public static void insertSort() {
    		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35,
    				25, 53, 51, 1, 96 };
    		int temp = 0;
    		for (int i = 1; i < a.length; i++) {
    			int j = i - 1;
    			temp = a[i];
    			for (; j >= 0 && temp < a[j]; j--) {
    				a[j + 1] = a[j]; // 将大于temp的值整体后移一个单位
    			}
    			a[j + 1] = temp;
    		}
    		for (int i = 0; i < a.length; i++) {
    			if (i % 10 == 9) {
    				System.out.print(a[i] + "\n");
    			} else {
    				System.out.print(a[i] + "\t");
    			}
    		}
    	}
    
    	/**
    	 * 希尔排序(最小增量排序) 基本思想:算法先将要排序的一组数按某个增量d(n/2,n为要排序数的个数)分成若干组,
    	 * 每组中记录的下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的增量(
    	 * d/2)对它进行分组,在每组中再进行直接插入排序。当增量减到1时,进行直接插入排序后,排序完成。
    	 */
    	public static void shellSort() {
    		int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };
    		double d1 = a.length;
    		int temp = 0;
    		while (true) {
    			d1 = Math.ceil(d1 / 2);
    			int d = (int) d1;
    			for (int x = 0; x < d; x++) {
    				for (int i = x + d; i < a.length; i += d) {
    					int j = i - d;
    					temp = a[i];
    					for (; j >= 0 && temp < a[j]; j -= d) {
    						a[j + d] = a[j];
    					}
    					a[j + d] = temp;
    				}
    			}
    			if (d == 1)
    				break;
    		}
    		for (int i = 0; i < a.length; i++) {
    			if (i % 10 == 9) {
    				System.out.print(a[i] + "\n");
    			} else {
    				System.out.print(a[i] + "\t");
    			}
    		}
    	}



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

    2019-09-15 11:10:58
    package mypackage; public class Hello { public static int[] random(int n,int ... //声明一个一维数组,并且为它申请空间 while(n>0) x[--n]=(int)(Math.random()*range); ret...
    package mypackage;
    
    public class Hello {
    	public static int[] random(int n,int range){  				//声明n为常量,方法体中不能赋值
    		int[] x=new int[n];   							//声明一个一维数组,并且为它申请空间
    		while(n>0)
    			x[--n]=(int)(Math.random()*range);
    		
    		return x;
    	}
    	public static int[] random(){						//方法重载
    		return random(10,100);
    	}
    	//输出一维数组
    	public static void print(final int[] x){		//声明value数组为常量,方法体中不能更改引用	
    		System.out.print("{");
    		if(x.length>0)
    			System.out.print(x[0]);
    		
    		for(int i=0;i<x.length;i++)
    			System.out.print(","+x[i]);
    		
    		System.out.print("}");
    	}
    	
    	public static void selectSort(int[] x){				//选择排序
    		for(int i=0;i<x.length-1;i++){
    			int min=i;
    			for(int j=i;j<x.length;j++){
    				if(x[j]<x[min]){
    					min=j;
    				}
    			}
    			if(i!=min){
    				int temp=x[i];
    				x[i]=x[min];
    				x[min]=temp;
    			}
    		}
    	}
    	public static int[] merge(int[] x,int[] y){			//将两个数组合并为一个数组
    		int z[]=new int[x.length+y.length],i=0,j=0,k=0;
    		while(i<x.length&&j<y.length)
    			if(x[i]<y[i])
    				z[k++]=x[i++];
    			else
    				z[k++]=y[j++];
    		while(i<x.length)
    			z[k++]=x[i++];
    		while(j<y.length)
    			z[k++]=y[j++];
    		return z;
    	}
    	public static void main(String[] args) {
    		int n1=7,range1=100;
    		int[] value1=random(n1,range1),value2=random(6,100);  //产生随机数
    		System.out.print("value1:");  print(value1);
    		System.out.print("value2:");  print(value2);
    		selectSort(value1); selectSort(value2);
    		System.out.print("sorted value1:");  print(value1);
    		System.out.print("sorted value2:");  print(value2);
    		System.out.print("merge:");  print(merge(value1,value2));
    	}
    
    }
    
    

    【运行结果】
    在这里插入图片描述

    展开全文
  • 维数组排序java

    2021-01-14 15:57:23
    维数组排序需要给个比较器 int [][] ans=new int[intervals.length][2]; Arrays.sort(intervals, new Comparator<int[]>() { @Override public int compare(int[] o1, int[] o2) { //现在是升序,...
  • 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_.
  • 维数组的创建及使用1、二维数组的创建2、二维数组初始化3、使用二维数组维数组的创建声明二维数组的方法有两种,语法如下所示:数组元素类型 数组名字[ ][ ];数组元素类型[ ][ ] 数组名字;数组元素类型:决定了...
  • Java维数组排序

    2020-05-19 08:58:30
    int [][]a = new int [5][2];...(特别注意,这里的a[][0]或者a[][1]在java中是不能这么定义的,这里只是想说明是对于某一个一维数组的第0或1个元素进行排序) Arrays.sort(a, new Comparator<int[]&
  • Java一维数组排序

    2019-03-24 21:08:48
    import java.util.*; public class Get { private static void AAA(int[] arr){ int temp; for(int i = 0; i ; i++) { for (int j = i + 1; j ; j++) { if (arr[i] > arr[j]) { temp = arr[j]; arr[j] = arr...
  • java笔记数组一维数组使用增强for循环遍历一维素组经典冒泡排序二维数组Arrays类的应用将所有元素赋相同的值查询元素在数组中的下标 数组 一维数组 **定义:**数组是用来存储一组相同类型数据的数据结构 注意:数组...
  • 1 题目描述在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。...
  • 欢迎在评论区提出你的问题or补充or解答)今天在敲代码的时候,发现个奇妙的点:(1)关于是否可以在定义时省略列在C语言中,二维数组无论如何定义的时候都不可以少了列。所以,以下的这种写法是错误的:int nuns[]...
  • ***解题思路***将二维数组抽调成一维数组,再又一维数组还原成二维数组 import java.util.Arrays;//引入Arrays类 public class test {public static void main(String[] args) { int array[][]={{11,4,2},{19,21,1}...
  • 我们来看一下如何使用冒泡排序算法对个整型数组从小到大进行排序:// 冒泡排序----import java.util.Arrays;public class Main {public static void main(String[] args) {int[] ns = { 28, 12, 89, 73, 65...
  • Java完成二维数组排序

    千次阅读 2019-04-11 00:17:43
    二维数组中(每个一维数组的长度相同),按照如下规则排序:每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序 public class HashMapTest { public static void main(String[] args) { ...
  • 运用java 实现二维数组排序 (排序要求为‘基于第个元素排序’组合不变) 三种排序方法分别为: 选择排序,插入排序和排列排序; //选择排序 public class Sort { public static void main(String[] args) { int...
  • 维数组排序,按照某列列大小对数组进行排序。二维数组的排序直接调用Arrays.sort(); 虽然不会出现编译错误,但运行时会出现以下错误提示: 说明不可以这样用,而我们又想对它排序,就可以使用Comparator来外部...
  • java一维数组排序及算法

    千次阅读 2016-08-02 09:30:05
    package com.axesline.sun; import java.util.Random; public class getMaxMin_Number {      public static void main(String[] args) {    int[] arry = new int[20];  Random r = new Ra
  • 1、一维数组的创建与使用 创建一维数组 数组元素类型 数组名字[]; 数组元素类型[] 数组名字; 数据元素类型决定了数组的数据类型。 ...
  • Java对二维数组排序

    2020-11-30 13:47:55
    排序规则:首先按照每个一维数组第一个元素进行升序排序,若第一个元素相等,则按照第二个元素进行升序排序。 Arrays.sort(a, new Comparator<int[]>() { @Override public int compare(int[] o1, int[] o2) {...
  • 一维数组排序:冒泡,选择,插入,比较效率 long start=System.currentTimeMillis(); //程序代码 long end=System.currentTimeMillis(); System.out.println("消耗时间:"+(end-start)+"毫秒");循环遍历数组的数据...
  • package A; public class B { public static void main(String[] args) { int[][] s = new int[10][10]; int t; for(int i = 0;... }//明明给第数组排序,结果第二个数组也变了 }
  • 对二维数组排序

    2019-09-04 08:49:13
    需要把二维数组看成是”每个元素是一维数组一维数组“,传入外比较器自定义比较规则。 import java.util.Arrays; import java.util.Comparator; public class RedBook { public static void main(String[] args)...
  • 自定义比较器类,继承Comparator,在Array.sort()中传入值。 public class Solution { public static void main(String[] args) { Integer[] arr = {4, 6, 3... // 实例化个Comparator对象 Arrays.sort(arr, c);

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,502
精华内容 600
关键字:

一维数组排序java

java 订阅