在一个方法中使用递归、无导入查找Java数组中的第k个最小元素

首先，让我确认我知道这样的主题存在，但我发现我的案例是独一无二的。首先，根据我的要求，我所有的代码都是，而且必须是，在一种方法中（这并不重要，但我发现这样做会使我更难保持概述）

第二，该方法必须使用递归（这对我来说是新的，所以我怀疑这就是我遇到的问题）

第三，该方法必须采用一个数组、一个键（是第k个最小的数）和两个整数，第一个和最后一个

第四，枢轴项始终必须是数组的第一个元素。我给了值“p”，你会在代码中看到

所以在这个方法中，我必须排序并找到为任何键提供的键（正如前面提到的，它是该方法作为参数的第k个数字）

我觉得这足够具体，足以证明它自己的问题，所以我在这里

首先，以下是我给自己的数字（我在网上随机找到了一些其他人试图解释一个类似但不相等的问题）：

也就是说，到目前为止，我一直在用这条线来测试这个方法

    System.out.println(findNth(b, 6, 0, b.length));

请注意，每个数字1、2、3、4和5都完美地返回了最低值、第二最低值、第三最低值等值，我真的以为我已经有一段时间了

我在6点撞车，在几个小时没有任何进展后，我决定请求帮助

这是我到目前为止所做的怪物长法：

    static public int findNth(int[] t, int key, int first, int last) {


    int p = t[0];

    int smallerSize = 0;
    int largerSize = 0;

    int[] smallerTab;
    int[] largerTab;

    for (int i = 0; i < t.length; i++) {
        if (t[i] < p) {
            smallerSize++;
        } else {
            largerSize++;
        }
    }

    smallerTab = new int[smallerSize];
    largerTab = new int[largerSize - 1];

    int i = 0;
    while (i < smallerTab.length) {
        for (int j = 0; j < t.length; j++) {
            if (t[j] < p) {
                smallerTab[i] = t[j];
                i++;
            }
        }
    }

    int y = 0;
    while (y < largerTab.length) {
        for (int j = 0; j < t.length; j++) {
            if (t[j] > p) {
                largerTab[y] = t[j];
                y++;
            }
        }
    }

    int c = 0;
    for (int a = 0; a < t.length; a++) {
        if (a < smallerTab.length) {
            t[a] = smallerTab[a];
        }
        if (a == smallerTab.length) {
            t[a] = p;
        }
        if (a > smallerTab.length) {
            t[a] = largerTab[c];
            c++;
        }
    }

    int index = 0;
    for (int d = 0; d < t.length; d++) {
        if (t[d] == p) {
            index = d;
        }
    }

    if (key < index - first + 1) {
        return findNth(smallerTab, key, 0, smallerTab.length - 1);
    }

    else if ((key == index - first + 1) || index == 0) {
        return p;
    }

    else {
        return findNth(largerTab, (key - (index - first + 1)), index + 1,
                largerTab.length);
    }

}

static public int findNth（int[]t，int key，int first，int last）{
int p=t[0]；
int smallerSize=0；
int largerSize=0；
int[]smallerTab；
int[]更大的选项卡；
对于（int i=0；ip）{
大表位[y]=t[j]；
y++；
}
}
}
int c=0；
for（int a=0；a小标签长度）{
t[a]=largerTab[c]；
C++；
}
}
int指数=0；
对于（int d=0；d

我谦卑地请求任何比我聪明的人帮助我克服这个问题

---

最好能解释一下我的错误在哪里，但如果能给我提供一些建议或代码，我将不胜感激

你是说第k个

最小的
元素吗？你是根据分区对数组进行排序吗？@Prince是的，我不清楚吗？我会更新问题的@是的，我被迫使用数组的第一个对象。谢谢你指出，因为我没有提到。问题已更新。@ViRALiC那么您正在实施快速排序？如果是这样的话，那么无论是在这里还是在网络上的其他地方，都不会缺少示例
    static public int findNth(int[] t, int key, int first, int last) {


    int p = t[0];

    int smallerSize = 0;
    int largerSize = 0;

    int[] smallerTab;
    int[] largerTab;

    for (int i = 0; i < t.length; i++) {
        if (t[i] < p) {
            smallerSize++;
        } else {
            largerSize++;
        }
    }

    smallerTab = new int[smallerSize];
    largerTab = new int[largerSize - 1];

    int i = 0;
    while (i < smallerTab.length) {
        for (int j = 0; j < t.length; j++) {
            if (t[j] < p) {
                smallerTab[i] = t[j];
                i++;
            }
        }
    }

    int y = 0;
    while (y < largerTab.length) {
        for (int j = 0; j < t.length; j++) {
            if (t[j] > p) {
                largerTab[y] = t[j];
                y++;
            }
        }
    }

    int c = 0;
    for (int a = 0; a < t.length; a++) {
        if (a < smallerTab.length) {
            t[a] = smallerTab[a];
        }
        if (a == smallerTab.length) {
            t[a] = p;
        }
        if (a > smallerTab.length) {
            t[a] = largerTab[c];
            c++;
        }
    }

    int index = 0;
    for (int d = 0; d < t.length; d++) {
        if (t[d] == p) {
            index = d;
        }
    }

    if (key < index - first + 1) {
        return findNth(smallerTab, key, 0, smallerTab.length - 1);
    }

    else if ((key == index - first + 1) || index == 0) {
        return p;
    }

    else {
        return findNth(largerTab, (key - (index - first + 1)), index + 1,
                largerTab.length);
    }

}