數組從大到小排序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]+"");
		}
	}
}