Java排序循环不起作用[关闭]答案

【问题标题】：Java sorting loop not working [closed]Java排序循环不起作用[关闭]
【发布时间】：2015-05-22 18:09:44
【问题描述】：

。基本上，以下代码的作用（假设）是，创建一组非重复随机数，将它们填充到一个数组中，该数组将转换为一个列表，然后对它们进行排序。问题是嵌套的 for 循环，我设法解决了问题，但甚至不确定它是如何工作的。其次，我似乎无法正确排序，事情会重复出现，并且不时弹出超出范围的错误。

代码的工作原理：

生成不重复的随机数
用它们填充数组
使用嵌套 for 循环查找最小值
将其插入新数组
从第一个数组中删除它

重复最后两个步骤，直到第一个数组为空，第二个数组为空 os按排序顺序填写

 import org.apache.commons.lang.ArrayUtils;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.*;
 import java.lang.*;
 import java.io.*;

 public class Sorter {

 public static void main(String[] args) {
int[] process = fillArray(20,1,25);
sorter(process,20);

}

public static int[] sorter(int array[],int size) {

int[] useArray = array;

Integer[] newArray = ArrayUtils.toObject(useArray);
List<Integer> arrayList = new ArrayList(Arrays.asList(newArray));


//System.out.println((arrayList));

int counter = 1;
int minval = 0;
int diffsize = size - 1;
int actualVal = 0;
int storeArray[] = new int[size];
int removeIndex =0;

Integer[] newStore = ArrayUtils.toObject(storeArray);
List<Integer> storeList = new ArrayList(Arrays.asList(newStore));

System.out.println((arrayList));

// Both loops messed up
for (int i = 0; i < size+diffsize; i++) {

    for (int n = 0; n < size-1; n++) {

        if (arrayList.get(minval) < arrayList.get(counter)) {
            actualVal = arrayList.get(minval);
             System.out.println((arrayList.get(minval)) + " Less than " + arrayList.get(counter));
            counter = counter + 1;
            removeIndex = minval;
        } else {
            actualVal = arrayList.get(counter);
            System.out.println((arrayList.get(counter)) + " Less than " + arrayList.get(minval));
            minval = counter;
            counter = counter + 1;
            removeIndex = counter;
        }
    }

   // System.out.println(actualVal);
    storeList.add(actualVal);
    arrayList.remove(actualVal); // need to remove the smallest value to repeat the sorting and get the next smallest value, but this is not removing it
    size = size - 1;
    counter = 1;
    minval = 0;
   // if (i + size == i) {
   //     storeList.set(i, arrayList.get(0));
   // }
   // System.out.println(removeIndex);

   // System.out.println(arrayList);
}


     // System.out.println(storeList);

      int[] ints = new int[storeList.size()];
      int d = 0;
      for (Integer u : storeList) {
         ints[d++] = u;
      }


    return ints;
 }


  public static int randomNum(int lower,int upper){
    Random rand = new Random();
    int randomNum = lower + rand.nextInt((upper- lower) + 1);
    return randomNum;
 }




 public static int[] fillArray(int size,int lowerBound,int upperBound){
     int holdArray[] = new int[size];

     int rand = 0;

    for (int count =0;count < holdArray.length;count++){
      holdArray[count] = 0;
   }

    for (int count =0;count < holdArray.length;count++){

       rand = randomNum(lowerBound,upperBound);
       if (ArrayUtils.contains(holdArray, rand)) {
           while (ArrayUtils.contains(holdArray, rand)) {
            rand = randomNum(0, 20);
        }
    }
    holdArray[count] = rand;
}
    // System.out.println(Arrays.toString(holdArray));

//return holdArray;

return holdArray;

}



}

【问题讨论】：

while (ArrayUtils.contains(holdArray, rand)) { rand = randomNum(0, 20); } 你没有使用你的界限。
分而治之。首先编写一个简单的排序函数并对其进行测试。您不想使用内置的排序方法来学习对吗？阅读冒泡排序或类似的东西并首先实现它。那么剩下的就容易多了。
我不明白。您有四个不同的Integer[] 数组，三个int[] 数组和两个ArrayLists。其中一些是原始数组的副本，一些用nulls 或零填充（它们都不是空的）。目前尚不清楚您在排序过程中实际阅读的是哪个，但很明显，附加到非空列表无法产生正确的结果。

标签： java arrays list sorting

【解决方案1】：

您能否给出一个令人信服的理由来证明从数组转换为列表的合理性？为什么不完全使用列表或仅使用数组？我在下面的回答中使用了 ArrayList；

首先，fillArray 类。您不需要全部填充零。为什么还要费心用一个无论如何都要替换的值来填充它？

public static ArrayList<Integer> fillArray(int size,int lowerBound,int upperBound){
    ArrayList<Integer> a = new ArrayList<Integer>(size);
    for (int count =0;count < size;count++){
       Integer rand = new Integer(randomNum(lowerBound,upperBound));
       a.add(rand);
    }
    return a;
}

第二，排序类。正如你所说的，你的方法是寻找最低值，然后做一些神奇的事情，而不是什么。

public static ArrayList<Integer> sorter(ArrayList<Integer> unsorted) {
ArrayList<Integer> sortedArray = new ArrayList<Integer>(unsorted.size());
while(!unsorted.isEmpty()) { //repeats until the unsorted list is empty
    int minval = unsorted.get(0);
    int removeIndex = 0;
    for(int i=1;i<unsorted.size();i++) 
        if (unsorted.get(i)<minval) {
            minval = unsorted.get(i);
            removeIndex = i;
        }
    sortedArray.add(minval);
    unsorted.remove(removeIndex);
    }
    return sortedArray;
}

主要测试方法

public static void main(String[] args) {
    ArrayList<Integer> a = fillArray(20,1,25);
    System.out.println("unsorted array");
    for (Integer c : a)
        System.out.print(c + ";");
    ArrayList<Integer> b = sorter(a);
    System.out.println("\nnew unsorted array");
    for (Integer c : a)
        System.out.print(c + ";");
    System.out.println("\nsorted array");
    for (Integer c : b)
        System.out.print(c + ";");
}

这个输出

unsorted array
22;2;23;22;13;12;4;1;7;14;25;18;9;12;3;8;20;3;1;20;
new unsorted array

sorted array
1;1;2;3;3;4;7;8;9;12;12;13;14;18;20;20;22;22;23;25;

【讨论】：

谢谢，这清除了很多东西。我选择列表的原因是，数组大小是固定的，不能扩展，在其他地方我可以更轻松地处理列表。
好的，但是这里几乎不需要 ArrayList。在您的情况下，ArrayList 和 Array 的实现都是相同的，因为我们已经在您调用 fillArray 时定义了数组的大小。
那么，您认为在性能、简单性和功能性方面哪个更好？
@user3227275 这是一个常见问题，你可以在 stackoverflow 上找到几十个关于ArrayList vs array 的问题，更不用说谷歌了:)。

【解决方案2】：

将数组中的“求最小”和“插入/删除”分成两个方法，然后使用。

这样代码将更易于管理。下面是一个示例find_min 方法。

int find_min(int[] array, int start) {
    int min = Integer.MAX_VALUE;
    for(int i = start; i < array.length; ++i)
        if(array[i] < min)
            min = array[i] ;
    return min;
}

现在在排序例程中，使用find_min 找到最小元素并将其插入新数组，然后从原始数组中删除最小元素。但是，此方法不返回最小元素的索引。因此，我建议您修改它以将索引和元素作为一对int 值返回。

您的排序例程将如下所示：

new_array := []
while(length(original_array) > 0)
    min, min_index := find_min(original_array)
    new_array.append(min)
    original_array.delete(min_index)

您可以使用类似的方法返回 int 对：

class IntPair {
    int min;
    int index;

    public IntPair(int x, int y) { this.min=x; this.index=y; }

    public int get_min() { return min; }
    public int get_min_index() { return index; }
}

此外，由于您将进行插入和删除，请改用 ArrayList。它具有删除特定索引处的元素并向其附加元素的方法。

注意：您概述的方法接近 Selection Sort 算法，在该算法中，我们将数组分成两部分（已排序的左侧部分和未排序的右侧部分）并从右侧重复选择最小元素数组并将其与左侧最右侧的元素交换。

min := array[0]
for(i := 0; i < array.length; ++i)
    for(j := i+1; j < array.length; ++j)
        if(array[j] < min)
            min = array[j]
            break
    swap(array[i], array[j])

在这种情况下，您不需要两个数组，也不需要删除或插入元素到数组中。

【讨论】：