Java 需要通过代码对整数数组进行排序的帮助吗

我一直在编写对数组列表中的整数进行排序的代码，但我的代码只返回了2个数字。有人能帮我理解我这里做错了什么吗。如何显示所有的数字？我数组中的数字

• ArrayList testNumbers=新的ArrayList（）
• 增加（48）
• 增加（3）
• 增加（23）
• 增加（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;
}

公共ArrayList列表排序（ArrayList编号）{
//创建变量以存储最大数量
int maxNumber=0；
//创建一个数组，用于存储已排序的数字
ArrayList sortedIntArray=新的ArrayList（）；
//循环遍历数字数组列表中的每个数字
对于（int i=0；imaxNumber）{
//将号码设置为新的最大号码
maxNumber=numbers.get（i）；
//将当前最大数添加到已排序数组
sortedIntArray.add（最大编号）；
//从数字数组中删除最大数字
移除（number.get（i））；
}
}
返回分拣机；
}

//飞机返回了

---

[48,99]

使用

java.util.Collections.sort（列表）

。或者您需要实现自己的排序算法吗？

我相信您想要归档一个经典的选择排序

也许可以试试好的老维基百科：

公共ArrayList列表排序（ArrayList编号）{
//创建变量以存储最大数量
int maxNumber=0；
//创建一个数组，用于存储已排序的数字
ArrayList sortedIntArray=新的ArrayList（）；
//循环遍历数字数组列表中的每个数字
对于（int i=numbers.size（）；i>0；i--）{
maxNumber=numbers.get（0）；
对于（int j=0；jmaxNumber）{
//将号码设置为新的最大号码
maxNumber=numbers.get（i）；
}
}
//将当前最大数添加到已排序数组
sortedIntArray.add（最大编号）；
//从数字数组中删除最大数字
移除（number.get（i））；
//将当前最大数添加到已排序数组
sortedIntArray.add（最大编号）；
}
返回分拣机；
}

基本上，您只添加大于所看到的最大值的数字。您还需要考虑较小的数字，并适当地存储它们。

如果仔细查看代码，如果您当前查看的数字不大于maxNumber，则代码不会起任何作用

---

它加48，因为48>0。然后它丢弃3和23，因为它们小于48。然后它加上99，因为它大于48。

当您正在查看的数组元素大于目前为止发现的最大数组元素时，您才添加到sortedIntArray。添加48，因为到目前为止您还没有找到任何。然后加上99，因为它比48大。

我猜你问这个是为了家庭作业。如果您不只是使用任何内置排序方法的托管语言，因为它比您编写的任何东西都要快。

您需要多次通过数组。目前，您所做的是发现每个数字都比数组中以前的所有数字都大。如果您真的只是在寻找一种选择排序（这不是一个好主意，它相当慢），您需要：

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

int size=numbers.size（）；
对于（int i=0；inumbers.get（maxNumber））
maxNumber=j；
}
SortedIntArray.add（number.get（maxNumber））；
删除（maxNumber）；
}

---

这也会从最大到最小返回数组，这不一定是您想要的。此外，通过从数字中删除，您正在更改阵列，以便在完成后它将不可用（除非您传递克隆）。一般来说，您需要重新考虑设置。

您混合了几种排序策略

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

公共ArrayList列表排序（ArrayList编号）{
//创建变量以存储最大数量
int maxNumber=0；
//创建一个数组，用于存储已排序的数字
ArrayList sortedIntArray=新的ArrayList（）；
//循环遍历数字数组列表中的每个数字
而（！numbers.isEmpty（））{
int i；
对于（i=0；i最大值）{
//将号码设置为新的最大号码
maxNumber=numbers.get（i）；
}
}
//将当前最大数添加到已排序数组
sortedIntArray.add（最大编号）；
//从数字数组中删除最大数字
number.listIterator（i）.remove（）；
maxNumber=0；//重置maxNumber
}
}
返回分拣机；
}

您正在处理条目时删除它们。 这意味着插入条目时，大小正在缩小。

---

添加两个条目后，删除了两个条目，留下两个条目，因此循环停止。

尝试此算法，它适用于类。。您还可以将类的列表插入其中

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

package-drawFramePackage；
导入java.awt.geom.AffineTransform；
导入java.util.ArrayList；
导入java.util.ListIterator；
导入java.util.Random；
公共类快速排序算法{
ArrayList affs；
列表迭代器李；
整数计数，count2；
/**
*@param args
*/
公共静态void main（字符串[]args）{
新的QuicksortAlgorithm（）；
}
公共QuicksortAlgorithm（）{
计数=新整数（0）；
count2=新整数（1）；
affs=新的ArrayList（）；
对于（int i=0；i 1&&count！=list.size（）-1）{
if（list.get（count2.getTranslateX（）>list.get（count.getTranslateX（））{
list.add（count，list.get（count2））；
列表。删除（count2+1）；
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());
        }
    }
}