选择排序不返回排序数组答案

【问题标题】：Selection Sort does not return a sorted array选择排序不返回排序数组
【发布时间】：2019-10-11 05:46:12
【问题描述】：

我正在尝试编写一个选择排序，在其中找到由 int 上限限制的（子）数组中的最大值，并将当前值与最大值交换。

我已经编写了三个独立的方法——我有一个查找数组中最大值的索引的方法，一个交换两个值的方法，以及一个用于实际排序的排序方法。我试过调试，但不是很擅长......

public static void sort(Comparable[] array)
   {
      int maxindex = 0;
      for(int k=0; k<array.length; k++)
      {
         maxindex = findMax(array, array.length-k);
         if(maxindex < k)
            swap(array, k, maxindex); 
      }   
   }

public static int findMax(Comparable[] array, int upper)
   {  //"upper" controls where the inner loop of the selection sort ends
      Comparable max = array[0];
      int maxindex = 0;
      for(int i = 1; i<upper; i++)
      {
         if(max.compareTo(array[i])<0)
         {
            max = array[i];
            maxindex = i;
         }
      }
      return maxindex;
   }

public static void swap(Object[] array, int a, int b)
   {
      Object save = array[b];
      array[b] = array[a];
      array[a] = save; 
   }

我生成一个随机数组并调用排序并打印出“排序后”的数组，只是打印出来的数组根本没有排序……

【问题讨论】：

请不要使用原始类型。您正在使用 Comparable 而不指定其泛型类型。这仍然是有效的 Java 的唯一原因是支持 Java 版本 4 和更早版本。没有正当理由使用原始类型，除非您正在使用这些版本。此外，你的交换方法应该是通用的，而不是接受Object[]，否则你可能会在编译器无法保护你的情况下污染你的堆..
感谢您指出这一点！我确实有一组非常相似的使用 double[] 数组的方法，但我的老师希望我两者都写。看到它们有多相似，我只是想包括我的 Comparable 方法
只是应该是public static <T> int findMax(Comparable<T>[] array, ...)`注意两个<T>。然后还有public static <T> void swap(T[] array, ...)。 IE。使它们成为泛型并使用 java 泛型而不是原始类型 :) 这为您提供了更多的类型安全性和编译器的帮助以避免错误。

标签： java arrays sorting max comparable

【解决方案1】：

我使用了您的代码并对sort 和findMax 函数进行了一些修改。现在，我们得到了正确的输出。

sort 函数：我不知道为什么你在交换之前有条件，它会阻止一些findMax 交换。另外，我猜你正在做array.length - k，因为你可能希望在最后一个索引中保持最大值并循环查找下一个最大值，依此类推。这样做你的逻辑似乎是错误的。
findMax 函数：索引应该从0 开始，一直到upper。

详情见以下代码：

public static void sort(int[] array) {
    int maxindex = 0;
    for(int k=array.length - 1; k >= 0; k--) {
        maxindex = findMax(array, k);
        swap(array, k, maxindex);
    }
}

public static int findMax(int[] array, int upper) {  
    //"upper" controls where the inner loop of the selection sort ends
    int max = array[0];
    int maxindex = 0;
    for(int i = 0; i <= upper; i++) {
        if(max < array[i]) {
            max = array[i];
            maxindex = i;
        }
    }
    return maxindex;
}

输入：[4, 2, 3, 8, 7, 1, 9, 10, 15, 12, 11, 13]

输出：[1, 2, 3, 4, 7, 8, 9, 10, 11, 12, 13, 15]

【讨论】：

【解决方案2】：

因为可比较是原始类型。对泛型 Comparable 的引用应该被参数化。除非必要，否则不建议使用原始数据类型。

以下程序对您的代码进行了少量修改。你可以比较一下，它运行在 O(n^2) 复杂度上。

您的代码中的主要问题是在 findMax() 函数中，该函数通过对值进行硬编码而变为静态。

import java.util.Arrays;

public class XYZ {
    public static void main(String args[]) {
        sort(new Integer[] { 1, 5, 2, 11, 4 });
    }

    public static void sort(Comparable[] array) {
        int maxindex = 0;
        for (int k = 0; k < array.length; k++) { 
            maxindex = findMax(array, k);
            if (maxindex > k)
                swap(array, k, maxindex);
            //  System.out.println(Arrays.toString(array));
        }
    }

    public static int findMax(Comparable[] array, int startIndex) {
        Comparable max = array[startIndex];
        int maxindex = 0;
        for (int i = startIndex; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
                maxindex = i;
            }
        }
        return maxindex;
    }

    public static void swap(Object[] array, int a, int b) {
        Object save = array[b];
        array[b] = array[a];
        array[a] = save;
    }
}

【讨论】：