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

我试图从未排序的int数组中获取第n个最小元素。这就是我迄今为止所尝试的：

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

如果尝试打印新数组，我会得到：

我认为这是正确的。但是，当我运行整个代码时，第二分钟是2，但应该是3。我错过了什么

---

提前谢谢

您需要使用QuickSelect算法

---

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

我尝试了不做太多更改。现在for循环将min和max移动到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);
}

//一个实现递归冒泡排序的函数

编辑1：我看了评论，发现你不能使用array.sort，我的建议是使用冒泡排序，然后再进行排序，你不能使用冒泡排序，或者它也是不允许的

---

编辑2：按排序完成，等等。

Waw，它使用递归调用工作。谢谢你能解释一下你做了什么吗？谢谢投赞成票。我从处理1元素数组的简单情况开始。接下来是初始化一个新数组。因为您想要得到min和max，所以在检查哪个元素是较小的元素之后，我将第一个元素放在newArray的开始和结束处。在for循环中，我检查原始数组的下一个元素是否小于newArray中的第一个元素，还是大于newArray中的最后一个元素，否则。我把这个元素放在适当的地方。循环后，最小值和最大值应位于第一位和最后一位。然后我从第二个元素开始检查子数组中的第n-1个最小值。如果不查找最大值元素，则可以更轻松。你不需要它。请记住，您可能希望在包含n+1个元素的数组中查找第n个min元素。感谢您提供的资源。我来看看。我刚刚试过代码，得到的结果与使用代码得到的结果相同。2而不是3。感谢@CommonMan的回复。不幸的是，我只能使用递归调用。等等，我正在做你的递归部分。不。我知道这个解决方案，但在我的用例中是不允许的。这是另一种优雅的方式。谢谢投票通过。@CommonMan我和这里的许多人一样，只是想让这个网站变得更好，每个人都会犯错。运行代码不再重要了，所以counts注释不再用于扩展讨论；这段对话已经结束。

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

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

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

}