按从低到高的顺序排列整数java

Question

这些数字存储在相同的整数变量中。我会如何按照从低到高排列整数？

11367 
11358 
11421 
11530 
11491 
11218 
11789

Answer 1

有两种选择，真正做到：

1. 使用标准的集合，as explained by Shakedown
2. 使用Arrays.sort

例如，

int[] ints = {11367, 11358, 11421, 11530, 11491, 11218, 11789}; 
Arrays.sort(ints); 
System.out.println(Arrays.asList(ints)); 

临屋当然，假设你已经将整数作为一个数组。 如果您需要首先解析这些文件，请查找String.split和Integer.parseInt。

Answer 2

你可以把它们放入一个列表，然后使用他们的自然顺序进行排序，像这样：

final List<Integer> list = Arrays.asList(11367, 11358, 11421, 11530, 11491, 11218, 11789); 
Collections.sort(list); 
// Use the sorted list 

如果号码存储在同一个变量，那么你就必须以某种方式把它们放在一个List，然后调用sort，就像这样：

final List<Integer> list = new ArrayList<Integer>(); 
list.add(myVariable); 
// Change myVariable to another number... 
list.add(myVariable); 
// etc... 

Collections.sort(list); 
// Use the sorted list 

• Collections.sort(List)

Answer 3

那么，如果你想使用算法来做到这一点。那里有很多排序算法。如果你不太关心效率，更关心可读性和可理解性。我推荐插入排序。这里是psudo代码，把它翻译成java是很简单的。

begin 
    for i := 1 to length(A)-1 do 
    begin 
     value := A[i]; 
     j := i - 1; 
     done := false; 
     repeat 
      { To sort in descending order simply reverse 
       the operator i.e. A[j] < value } 
      if A[j] > value then 
      begin 
       A[j + 1] := A[j]; 
       j := j - 1; 
       if j < 0 then 
        done := true; 
      end 
      else 
       done := true; 
     until done; 
     A[j + 1] := value; 
    end; 
end; 

Answer 4

对于整数范围窄的整数尝试Counting sort，其复杂度为O(range + n)，其中n是要排序的项目数。如果您想对不是离散使用最优的n * log（n）算法（quicksort,heapsort,mergesort）进行排序。合并排序也用于其他响应Arrays.sort已提及的方法。如何推荐一些算法或函数调用没有简单的方法，因为有几十种特殊情况，您可以使用某种类型，但不使用其他类型。所以请指定你的应用程序的确切目的（学习一些东西（从插入排序或冒泡排序开始），整数的有效性（使用计数排序），结构的有效性和可重用性（使用n * log（ n）算法），或者只是希望它以某种方式排序 - 使用Arrays.sort :-)）。如果你想，如果中的Array.sort没有你想找的为整数的字符串表示

Answer 5

排序，比ü可能在基数排序来interrested ....你可以试试这个：

package drawFramePackage; 
import java.awt.geom.AffineTransform; 
import java.util.ArrayList; 
import java.util.ListIterator; 
import java.util.Random; 
public class QuicksortAlgorithm { 
    ArrayList<AffineTransform> affs; 
    ListIterator<AffineTransform> li; 
    Integer count, count2; 
    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     new QuicksortAlgorithm(); 
    } 
    public QuicksortAlgorithm(){ 
     count = new Integer(0); 
     count2 = new Integer(1); 
     affs = new ArrayList<AffineTransform>(); 
     for (int i = 0; i <= 128; i++){ 
      affs.add(new AffineTransform(1, 0, 0, 1, new Random().nextInt(1024), 0)); 
     } 
     affs = arrangeNumbers(affs); 
     printNumbers(); 
    } 
    public ArrayList<AffineTransform> arrangeNumbers(ArrayList<AffineTransform> list){ 
     while (list.size() > 1 && count != list.size() - 1){ 
      if (list.get(count2).getTranslateX() > list.get(count).getTranslateX()){ 
       list.add(count, list.get(count2)); 
       list.remove(count2 + 1); 
      } 
      if (count2 == list.size() - 1){ 
       count++; 
       count2 = count + 1; 
      } 
      else{ 
      count2++; 
      } 
     } 
     return list; 
    } 
    public void printNumbers(){ 
     li = affs.listIterator(); 
     while (li.hasNext()){ 
      System.out.println(li.next()); 
     } 
    } 
} 

Answer 6

接受来自用户和插入排序的输入。以下是它的工作方式：

package com.learning.constructor; 

import java.util.Scanner; 



public class InsertionSortArray { 

public static void main(String[] args) {  

Scanner s=new Scanner(System.in); 

System.out.println("enter number of elements"); 

int n=s.nextInt(); 


int arr[]=new int[n]; 

System.out.println("enter elements"); 

for(int i=0;i<n;i++){//for reading array 
    arr[i]=s.nextInt(); 

} 

System.out.print("Your Array Is: "); 
//for(int i: arr){ //for printing array 
for (int i = 0; i < arr.length; i++){ 
    System.out.print(arr[i] + ","); 

} 
System.out.println("\n");   

    int[] input = arr; 
    insertionSort(input); 
} 

private static void printNumbers(int[] input) { 

    for (int i = 0; i < input.length; i++) { 
     System.out.print(input[i] + ", "); 
    } 
    System.out.println("\n"); 
} 

public static void insertionSort(int array[]) { 
    int n = array.length; 
    for (int j = 1; j < n; j++) { 
     int key = array[j]; 
     int i = j-1; 
     while ((i > -1) && (array [i] > key)) { 
      array [i+1] = array [i]; 
      i--; 
     } 
     array[i+1] = key; 
     printNumbers(array); 
    } 
} 

}