Question

我正试图从未排序的int数组中获取nTh个最小元素。到目前为止，这是我尝试过的：

private static int nthMin(int[] array, int m) {
    int start = 0;
    int end = array.length - 1;
    int index = 0;
    int[] newArray = new int[array.length];
    for(int i = 0; i < array.length; i++) {
        if(array[i] < array[index]) {
            newArray[start] = array[i];
            start++;
        } else {
            newArray[end] = array[i];
            end--;
        }
        //System.out.println(Arrays.toString(newArray));
    }
    if(m > start) {
        return nthMin(Arrays.copyOfRange(newArray, start + 1, newArray.length), m - start);
    } else if(m < start) {
        return nthMin(Arrays.copyOfRange(newArray, 0, start), m);
    } else {
        return array[start];
    }
}

我正在使用以下方法调用此方法：

int[] array = {10, 2, 5, 6, 11, 3, 15};
System.out.println(nthMin(array, 2));

如果尝试打印newArray，我会得到：

[2, 5, 6, 3, 15, 11, 10]

我认为这是正确的。但是，当我运行整个代码时，我得到的第二分钟为2，但应该为3。我想念什么？

谢谢！

Answer 1

我尝试改变的幅度不大。现在，for循环将最小值和最大值移至newArray的开始/结尾，然后移至该方法的另一个调用。

private static int nthMin(int[] array, int m) {
    if ((array.length == 1) && (m == 1)) {
        return array[0];
    }

    int start = 0;
    int end = array.length - 1;
    int[] newArray = new int[array.length];

    if (array[0] < array[1]) {
        newArray[start] = array[0];
        newArray[end] = array[1];
    } else {
        newArray[start] = array[1];
        newArray[end] = array[0];
    }

    start++;
    end--;
    for (int i = 2; i < array.length; i++) {
        if (array[i] < newArray[0]) {
            newArray[start] = newArray[0];
            newArray[0] = array[i];
            start++;
        } else if (array[i] > newArray[array.length - 1]) {
            newArray[end] = newArray[array.length - 1];
            newArray[array.length - 1] = array[i];
            end--;
        } else {
            newArray[start] = array[i];
            start++;
        }
        System.out.println(Arrays.toString(newArray));
    }

    if (m == 1) {
        return newArray[0];
    }
    return nthMin(Arrays.copyOfRange(newArray, 1, newArray.length), m - 1);
}

Answer 2

//实现递归气泡排序
的功能

static void bubbleSort(int arr[], int n) 
{ 
    // Base case 
    if (n == 1) 
        return; 

    // One pass of bubble sort. After 
    // this pass, the largest element 
    // is moved (or bubbled) to end. 
    for (int i=0; i<n-1; i++) 
        if (arr[i] > arr[i+1]) 
        { 
            // swap arr[i], arr[i+1] 
            int temp = arr[i]; 
            arr[i] = arr[i+1]; 
            arr[i+1] = temp; 
        } 

    // Largest element is fixed, 
    // recur for remaining array 
    bubbleSort(arr, n-1); 
}

//驱动程序方法

public static void main(String[] args) 
{ 
    int arr[] = {2, 5, 6, 3, 15, 11, 10}; 

    bubbleSort(arr, arr.length); 
      System.out.println("Enter nth Min element you want");
        Scanner sc = new Scanner(System.in);
        int nth = sc.nextInt();
       System.out.println("Nth Min element in your array is: "+arr[nth-1]);

}

编辑1 ：我阅读了注释，发现您不能使用arrays.sort（），我的建议是先使用冒泡排序然后进行排序，不能使用冒泡排序或其还不允许吗？

编辑2：按recursive bubble排序完成，请等待。

Answer 3

您需要使用QuickSelect算法 Github unnikked/QuickSelect.java

您可以在这里找到一个迭代和递归的解决方案，以使您的代码更好。

尝试从Java中未排序的数组中获取第n个min元素时，结果错误

3 个答案: