数组从大到小排序java

⑴ 用java编程序 对一个由5个整数组成的数组,按照其内元素的从大到小排序

你好 看了楼上的解答 基本都是对的 但是 最悉颤后还是和你的要求不符 因为 sort排序 是指从小到大
而 提问者的要求是从大到小 所哪郑以修改如下李陆颂（我偷点懒就在他的基础上修改成你的要求就好）：
public class Test {
public static void main(String[] args) {
int []a=new int[5];
Scanner in=new Scanner(System.in);
System.out.print("输入5个数：");
for(int i=0;i<5;i++){
a[i]=in.nextInt();
}
Arrays.sort(a);//这里排出来是从小到大
for(int i=0;i<2;i++){ //这里做的就是一个倒序的处理 将由小到大 改为由大到小
int temp=0;
temp=arr[i];
arr[i]=arr[arr.length-i-1];
arr[arr.length-i-1]=temp;
}
System.out.println("输出：");
for (int output : a) {
System.out.print(output);
}
希望能帮到你 谢谢

⑵ Java问题， 输出n个范围在1~10000的不同的随机数，并且以从大到小的顺序排列

为了让你看的清楚,取随即数的方法写的很仔细:看懂了这个方法,很多地方都用的到
package com.soft.bean;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class SortTest {
//从一个给定的数组arr中,随机返回num个不重复项
public Integer[] getArrayItems(Integer[] arr, int num) {
//新建一个数组,将传入的数组复制过来,用于运算,而不要直接操作传入的数组;
Integer[] temp_array = Arrays.Of(arr, arr.length);
//取出的数值项,保存在此数组
Integer[] return_array = new Integer[num];
for (int i = 0; i < num; i++) {
//判断如果数组还有可以取出的元素,以防下标越界
if (temp_array.length > 0) {
//在数组中产生一个随机索引
int arrIndex = (int) Math.floor(Math.random() * temp_array.length);
//将此随机索引的对应的数组元素值复制出来
return_array[i] = temp_array[arrIndex];
//然后删掉此索引的数组元素,这时候temp_array变为新的数组
//System.array(arr, 0, temp_array, 0, arrIndex);
//System.array(arr, arrIndex+1, temp_array, arrIndex, temp_array.length-arrIndex);
temp_array = removeArrayItem(temp_array,arrIndex);
} else {
//数组中数据项取完后,退出循环,比如数组本来只有10项,但要求取出20项.
break;
}
}
return return_array;
}
// 写一个泛型方法可以适应大部份类型的需求。
// ----------------------------------------------
/**
* @param <T> 数组中的元素类型
* @param arrs 需要删除元素的数组。
* @param index 需要删除的元素的索引（出界时抛异常）。
* @return 指定类型的新数组。
*/
public static <T> T[] removeArrayItem(T[] arrs, int index) {
int len = arrs.length;
if(index < 0 || index >= len) {
throw new IllegalArgumentException("索引出界");
}
List<T> list = new LinkedList<T>();
for(int i = 0; i < len; i++) {
if(i != index) {
list.add(arrs[i]);
}
}
// 这里将改变传入的数组参数 arrs 的值
arrs = list.toArray(arrs);
return java.util.Arrays.Of(arrs, arrs.length - 1);
}
public static void main(String[] args) {
Integer[] arr = new Integer[10000];
System.out.println("输入一个N值：");
Scanner reader = new Scanner(System.in);
int n = reader.nextInt();
for(int i=1;i<=10000;i++){
arr[i-1]=i;
}
SortTest st = new SortTest();
Integer[] my_array = st.getArrayItems(arr,n);
//用sort()方法排序
Arrays.sort(my_array,Collections.reverseOrder());
for(int i=0;i<my_array.length;i++){
System.out.println(my_array[i]);
}

}
}

⑶ java求前k个最大数1秒内循环10000次

问题描述：求一个数组的最大k个数，如，{1,5,8,9,11,2,3}的最大三个数应该是，8,9,11

问题分析：

1.解法一：最直观的做法是将数组从大到小排序，然后选出其中最大的K个数，但是这样的解法，复杂度是O（logn*n），但是有时候并不需要排序，用简单的选择排序，或者是冒泡排序，那么就K轮的交换或者是选择，就可以得出结论，复杂度是O（n*k），当K很大的时候排序可能是更好的解法，当K小的时候用选择或者是冒泡效率会更加的高。但是这都是会对前K个数进行排序，所以效率不高，当K很大的时候，以上两种方法效率都不是很高。

2.解法二：不对前K个数进行排序，回忆快排的算法中，那个partition函数，就是随机选择数组中的一个数，把比这个数大的数，放在数组的前面，把比这个数小的数放在数组的

后面，这时想如果找出的随机数，最终位置就是K，那么最大的K个数就找出来了，沿着这个思路思考问题，但是这个函数，最后的索引位置并不一定是K，可能比K大也可能比K小，我们把找出的数组分成两部分sa，sb，sa是大的部分，sb是小的部分，如果sa的长度等于K的话，那么直接返回就是最终结果，如果sa的长度要比K大的话，那么以sa为新的数组，从sa中找出K个最大的数，这时候就把原始数据集减少到的sa，如果sa的长度比K小的话，加入sa中有m个元素，那么m个元素算作是K中元素的一部分，再从sb中找到，k-m个最大的元素，组合起来就是最终的结果，那么这时把问题简化成从sb中找k-m个最大的元素，所以总体来说这是一个递归的过程，虽然复杂大也是O（n*logn）但是，每一次数据量都会减少所以会更加的快。

3.解法三：是利用堆排序，建立一个K阶最大堆，然后数据一个个插入队当中，那么插入队的时间复杂度是O（logK），适合数据量比较大的时候，用堆的效果更加好。

⑷ Java数组排序 几种排序方法详细一点

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。

快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。

冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。

选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。

插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。

<1>利用Arrays带有的排序方法快速排序

publicclassTest2{
publicstaticvoidmain(String[]args){
int[]a={5,4,2,4,9,1};
Arrays.sort(a);//进行排序
for(inti:a){
System.out.print(i);
}
}
}

<2>冒泡排序算法

publicstaticint[]bubbleSort(int[]args){//冒泡排序算法
for(inti=0;i<args.length-1;i++){
for(intj=i+1;j<args.length;j++){
if(args[i]>args[j]){
inttemp=args[i];
args[i]=args[j];
args[j]=temp;
}
}
}
returnargs;
}

<3>选择排序算法

publicstaticint[]selectSort(int[]args){//选择排序算法
for(inti=0;i<args.length-1;i++){
intmin=i;
for(intj=i+1;j<args.length;j++){
if(args[min]>args[j]){
min=j;
}
}
if(min!=i){
inttemp=args[i];
args[i]=args[min];
args[min]=temp;
}
}
returnargs;
}

<4>插入排序算法

publicstaticint[]insertSort(int[]args){//插入排序算法
for(inti=1;i<args.length;i++){
for(intj=i;j>0;j--){
if(args[j]<args[j-1]){
inttemp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}elsebreak;
}
}
returnargs;
}

⑸ java怎么让数组的数字从大到小排序

将数字从大到小排序的方法：

例如简一点的冒泡排序，将第一个数字和后面的数字逐个比较大小，如果小于，则互换位置，大于则不动。此时，第一个数为数组中的最大数。然后再将第二个数与后面的数逐个比较，以次类推。

示例代码如下：
publicclassTest{

publicstaticvoidmain(String[]args){
int[]array={12,3,1254,235,435,236,25,34,23};
inttemp;
for(inti=0;i<array.length;i++){
for(intj=i+1;j<array.length;j++){
if(array[i]<array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp; //两个数交换位置
}
}
}
for(inti=0;i<array.length;i++){
System.out.print(array[i]+"");
}
}
}

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99

(5)数组从大到小排序java扩展阅读

Java中利用数组进行数字排序一般有4种方法：

1、选择排序是先将数组中的第一个数作为最大或最小数，然后通过循环比较交换最大数或最小数与一轮比较中第一个数位置进行排序。

2、冒泡排序也是先将数组中的第一个数作为最大或最小数，循环比较相邻两个数的大小，满足条件就互换位置，将最大数或最小数沉底。

3、快速排序法主要是运用Arrays类中的Arrays.sort方法（）实现。

4、插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。

⑹ Java：运用选择排序法，将十个数存入数组a中，通过输入对话框任意输入十个数，从大到小排列

importjava.util.Scanner;

publicclassTest{
	publicstaticvoidmain(String[]args){
		Scannerscanner=newScanner(System.in);
		int[]a=newint[10];
		intcount=0;
		while(count<10){
			System.out.print("输入第【"+(count+1)+"】个数：");
			a[count]=scanner.nextInt();
			count++;
		}
		System.out.print("
排序之前：");
		for(inti=0;i<a.length;i++){
			System.out.print(a[i]+"");
		}
		//选择排序
		for(inti=0;i<a.length-1;i++){
			intmin=i;
			for(intj=i+1;j<a.length;j++){
				if(a[min]<a[j]){
					min=j;
				}
			}
			if(min!=i){
				inttemp=a[i];
				a[i]=a[min];
				a[min]=temp;
			}
		}
		System.out.print("
排序之后：");
		for(inti=0;i<a.length;i++){
			System.out.print(a[i]+"");
		}
	}
}