Question

我的主要目标是从数组中定义的起始位置迭代到数组的末尾以找到最小值的索引然后将其与索引零交换，迭代将继续将其交换为高于1的索引以前的。我有一个方法，找到数组的最小值和我尝试获取最小值索引的方法。这就是我所拥有的：

   static int min(int[] parameter){
       int minValue = 101;
       for(int z = 0 ; z<parameter.length; z++){
           if(parameter[z] < minValue){
           minValue = parameter[z];
           }
       }
       return minValue;
    }

    static int locateMin (int start, int[] array) {
        int n = 0;
        int value = array[n]; 
        int location = 0;
        for (n= start; n < array.length; n++) {
            if (array[n] < value){ 
                value = array[n];
                location = n;
            }
        }
        return location;

    }
    static void swap(int[] arr, int locationOne, int locationTwo){
        int pos = arr[locationOne];
        arr[locationOne] = arr[locationTwo];
        arr[locationTwo] = pos;
   }

   public static void main(String[] args){
        int[] array = generateArray(10);
        showArray(array);
        swap(array, 0, locateMin(0, array));
        swap(array, 1, locateMin(1, array));
        swap(array, 2, locateMin(2, array));
        showArray(array);
   }

我的问题是它没有将值放在正确的索引中，并且迭代不正确。任何想法为什么？此外，我目前的输出显示：

63 10 47 94 89 68 15 12 27 42 
10 10 10 94 89 68 15 12 27 42

Answer 1

public static void main(String[] args){
        int[] array = generateArray(10);
        showArray(array);
        swap(array, 0, locateMin(0, array));
        swap(array, 1, locateMin(1, array));
        swap(array, 2, locateMin(2, array));
        showArray(array);
   }

这是硬编码的，如果不小心可能会产生许多错误。我建议迭代这个切换。此外，您似乎正在进行选择排序。

您的min函数似乎也没有在任何地方使用。

编辑：

public static <T extends Comparable<T>> int minValIndex(int start, T array[]) {
    int minIndex = start;

    for (int cLoc = start; cLoc < array.length; cLoc++) {
        minIndex = (array[cLoc].compareTo(array[minIndex]) < 0) ? cLoc : 
                minIndex;
    }

    return minIndex;
}

public static <T> void swap(T array[], int loc1, int loc2) {
    T temp = array[loc1];
    array[loc1] = array[loc2];
    array[loc2] = temp;
}

这些方法用于查找minIndex并交换两个索引。您可以使用这两种方法。在你的main方法中，你需要先生成一个数组，然后像你一样对数组进行循环排序。

Answer 2

我可以看到的问题是在你的locateMin函数中，当它检查的元素已经是最小值时。

static int locateMin (int start, int[] array) {
    int n = 0;
    int value = array[n]; 
    int location = 0; //Location is set to 0
    for (n= start; n < array.length; n++) {
        if (array[n] < value){ //There are no values smaller than it.
            value = array[n];
            location = n;
        }
    }
    return location; //returns 0

}

您应该将n设置为start，并将其用作location的值。

    int n = start;
    //...
    int location = n;

Answer 3

您在n = 0设置了locateMin(...)，因此您设置了int value = array[n];
即value = array[0]，这意味着您最初将数组的第一个值设置为最小值并使用它进一步比较只需替换以下内容：

int n = 0;
int value = array[n]; 
int location = 0;

来自locateMin(...)的

：

int n = array.length - 1;
int value = array[n];
int location = n;

Int数组迭代？

3 个答案: