Java 将给定值的较大数字向右移动，将较小数字向左移动

我有一个家庭作业问题，它给了我这个数组：

[3,22,1,5,6,10,4]

我需要将所有大于最后一个值4的数字移到该值的右边，并将所有小于该值的数字移到左边

数字不一定要按顺序排列。因此，程序的输出将是：

[3,1,4,22,5,6,10]

出于某种原因，我真的很难想出一种算法来实现这一点。我曾尝试创建一个循环，用较大的数字交换最后一个值，但如果数组中的某个奇数处混合了最小值，它将位于不正确的值的右侧

---

有人能帮我做这件事吗？

我不会帮你完成家庭作业的。但我会引导你们思考你们的例子将走向何方。这是快速排序的第一步——对数组进行分区

public class QuickSortImpl {

    private static void swap(int[] array, int l, int h) {
        int temp = array[h];
        array[h] = array[l];
        array[l] = temp;
    }

    public static int partition(int[] array, int low, int high) {
        int pivot = high;
        int firsthigh = low;
        int x,y;

        for (int i = low; i < high; i++) {
            x = array[i];
            y = array[pivot];
            if (array[i] < array[pivot]) {
                swap(array, i, firsthigh);
                firsthigh++;
            }
        }
        swap(array, pivot, firsthigh);
        return firsthigh;
    }

    private static void printArray(int[] arr ) {
        for ( int i =0; i < arr.length; i++ ) {
            System.out.print(" " + arr[i]);
        }
        System.out.println();
    }

    public static void quickSort(int[] array, int low, int high) {
        if ( low < high ) {
            int pivot = partition(array, low, high);
            quickSort(array, low, pivot - 1);
            quickSort(array, pivot + 1, high); 
        }
    }

    public static void main(String[] args) {
        int[] arr = { 3, 22, 1, 5, 6, 10, 4};
        quickSort(arr, 0, arr.length -1 );
        printArray(arr);
    }
}

公共类QuickSortImpl{
私有静态无效交换（int[]数组，int l，int h）{
int temp=数组[h]；
数组[h]=数组[l]；
数组[l]=温度；
}
公共静态int分区（int[]数组、int低、int高）{
int轴=高；
int firsthigh=低；
int x，y；
对于（int i=低；i<高；i++）{
x=数组[i]；
y=数组[枢轴]；
if（数组[i]<数组[pivot]）{
交换（数组，i，firsthigh）；
firsthigh++；
}
}
交换（阵列、枢轴、第一高）；
返回第一高；
}
私有静态void打印数组（int[]arr）{
对于（int i=0；i

@brent_mb，看看这个简单的例子：

public static void main(String[] args) {
        Integer[] listOfNumbers = {1,4,5,6,74,2,7,8,5,2,6,989,3};
        //sort by number 6
        FirstCustomComparator comparator = new FirstCustomComparator(6);

        Arrays.sort(listOfNumbers, 0, listOfNumbers.length, comparator);

        for (int number : listOfNumbers) {
            System.out.print(number+" ");
        }
    }

FirstCustomComparator类：

公共类FirstCustomComparator实现Comparator{
私人最终int例外；
公共FirstCustomComparator（int i）
{
异常=i；
}
@凌驾
公共整数比较（整数a、整数b）
{
如果（a<例外）
{
返回-1；
}
返回a.compareTo（b）；
}
}

是否必须安装到位？i、 e.是否存在只使用一个数组的限制？@Jesse是的，应该只有一个数组。在重新排列数组之前不应该对其进行排序。这是经典的快速排序算法。但是，您需要将pivot保持在4，并进行第一次迭代。一旦你准备好更改透视，你就会停止。并且提示：如果你只是对整个数组进行正常的完全排序，你也会达到目标条件。@GhostCat会的，但是指令不允许进行正常选择或二进制排序，所以Roy是正确的，我只需要处理快速排序的第一个透视谢谢！这实际上不是一个家庭作业问题，而是一个今天困扰我的测试问题。我们还没有学会快速排序算法，所以我很惊讶我们会知道这一点。这肯定是正确的答案。@ BruttMB，一开始我会考虑实施自定义比较器，更容易，更干净，并适合您的水平，但这也是一个很好的例子。

public class FirstCustomComparator implements Comparator<Integer> {

    private final int exception;

    public FirstCustomComparator(int i)
    {
        exception = i;
    }

    @Override
    public int compare(Integer a, Integer b)
    {
        if (a < exception)
        {
                return -1;

        }
        return a.compareTo(b);
    }
}