需要幫助的分揀通過代碼

Question

我一直對代碼進行排序在數組列表整數一個整數數組，但我的代碼只返回只有2號任何人可以幫助我理解我在做什麼錯在這裏。我如何獲得所有要顯示的數字？我的陣列中的數字

• ArrayList testNumbers = new ArrayList（）;
• testNumbers.add（48）;
• testNumbers.add（3）;
• testNumbers.add（23）;
• testNumbers.add（99）;

[48,3,23,99]。任何幫助將不勝感激。

public ArrayList<Integer> listSort(ArrayList<Integer> numbers) { 

    // create variable to store max number 
    int maxNumber = 0; 

    // creates an array that will store the sorted numbers 
    ArrayList<Integer> sortedIntArray = new ArrayList<Integer>(); 

    // loops through each number in the numbers arraylist 
    for (int i = 0; i < numbers.size(); i++) { 

     if (numbers.get(i) > maxNumber) { 
      // set the number to the new max number 
      maxNumber = numbers.get(i); 

      // add current max number to sorted array 
      sortedIntArray.add(maxNumber); 

      // remove the max number from numbers array 
      numbers.remove(numbers.get(i)); 

     } 
    } 



    return sortedIntArray; 
} 

//所述sortedIntArray返回 [48,99]

Answer 1

使用java.util.Collections.sort(List<T> list)。或者你是否需要實現自己的排序算法？

Answer 2

我相信要存檔一個經典的選擇排序。

也許嘗試好老維基百科：http://en.wikipedia.org/wiki/Selection_sort

public ArrayList<Integer> listSort(ArrayList<Integer> numbers) { 

    // create variable to store max number 
    int maxNumber = 0; 

    // creates an array that will store the sorted numbers 
    ArrayList<Integer> sortedIntArray = new ArrayList<Integer>(); 

    // loops through each number in the numbers arraylist 
    for (int i = numbers.size(); i > 0; i--) { 
     maxNumber = numbers.get(0); 
     for(int j = 0; j < numbers.size(); j++) { 
      if (numbers.get(j) > maxNumber) { 
       // set the number to the new max number 
       maxNumber = numbers.get(i); 
      } 
     } 
     // add current max number to sorted array 
     sortedIntArray.add(maxNumber); 

     // remove the max number from numbers array 
     numbers.remove(numbers.get(i)); 

     // add current max number to sorted array 
     sortedIntArray.add(maxNumber); 
    } 
    return sortedIntArray; 
} 

Answer 3

基本上你只補充說，比你見過的最大數量更大的數字。您還需要考慮較小的數字，並妥善保存。

Answer 4

如果你把你的代碼仔細一看，它不會做任何事情，如果您現在所看到的數量不超過MAXNUMBER更大。

它增加了在48，因爲48> 0。然後它丟棄3和23，因爲它們是小於48.然後將其添加99，因爲它是大於48

Answer 5

你只添加到sortedIntArray當陣列你看的元素比迄今爲止發現的最大。 48被添加，因爲到目前爲止還沒有找到。然後99被添加，因爲它是大於48

Answer 6

我猜你是問這個的家庭作業。如果你不只是使用任何在sort方法中構建的託管語言，因爲它比你寫的任何東西都要快。

Answer 7

你需要通過陣列不止一次。就目前而言，你正在做的是找到比數組中所有前面的數字更大的數字。如果你真的只是尋找一個選擇排序（不是一個好主意，這是很慢）你想：

int size = numbers.size(); 
for (int i = 0; i < size; i++) 
{ 
    int maxNumber = 0; 
    for (int j = 0; j < numbers.size(); j++) 
    { 
     if (numbers.get(j) > numbers.get(maxNumber)) 
      maxNumber = j; 
    } 
    SortedIntArray.add(numbers.get(maxNumber)); 
    numbers.remove(maxNumber); 
} 

這也將返回您的陣列從最大到最小，這不一定是你想要的。此外，通過從數字中刪除，您將更改數組，以便在完成後不會提供給您（除非您傳遞克隆）。一般來說，你需要重新考慮你的設置。

Answer 8

你幾個混合分揀strats

public ArrayList<Integer> listSort(ArrayList<Integer> numbers) { 

    // create variable to store max number 
    int maxNumber = 0; 

    // creates an array that will store the sorted numbers 
    ArrayList<Integer> sortedIntArray = new ArrayList<Integer>(); 

    // loops through each number in the numbers arraylist 
    while (!numbers.isEmpty()) { 
     int i; 
     for(i=0;i<number.size();i++){//double loop to get the current max numbers 
      if (numbers.get(i) > maxNumber) { 
       // set the number to the new max number 
       maxNumber = numbers.get(i); 
      } 
     } 
     // add current max number to sorted array 
     sortedIntArray.add(maxNumber); 
     // remove the max number from numbers array 
     number.listIterator(i).remove(); 
     maxNumber=0;//reset maxNumber 
     } 
    } 



    return sortedIntArray; 
} 

Answer 9

爲你處理它們你要刪除的條目。 這意味着插入條目時大小縮小。 添加兩個條目後，您已刪除兩個條目留下兩個條目，因此循環停止。

Answer 10

試試這個算法它與類..你可以插入類的列表到它，以及

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()); 
     } 
    } 
}