Java 找出数组是否包含给定范围内的数字

因此，我遇到了一个问题，要实现一个程序，如果排序整数数组包含大于

I

但小于

u

，则返回

true

，否则返回

false

我发现快速排序算法是对数组进行排序的好方法，因为我不知道用户将如何输入它-然后，我将排序后的数组馈送到二进制搜索，并找出数组是否包含指定范围内的整数。 问题是，我似乎无法对此进行推理，因为这不是我想要在这里找到的一个值，而是一个范围。 而且，如果可能的话，我想递归地实现这个

以下是我目前掌握的情况：

import java.util.Scanner;

class RangeBinarySearch {
    public static int[] quickSort(int[] unsortedArray, int left, int right) {
    int[] sortArray = unsortedArray;
    if (left >= right)
        return sortArray;

    int pivot = unsortedArray[(left + right) / 2];

    int i = left;
    int j = right;

    while (i <= j) {
        while (unsortedArray[i] < pivot)
            i++;
        while (unsortedArray[j] > pivot)
            j--;
        if (i <= j) {
            int temp = unsortedArray[i];
            unsortedArray[i] = unsortedArray[j];
            unsortedArray[j] = temp;
            i++;
            j--;
        }
    }

    if (left < j)
        quickSort(unsortedArray, left, j);
    if (right > i)
        quickSort(unsortedArray, i, right);

    return sortArray;
    }

    public static boolean withinRangeSorted(int[] sortedArray, int I, int u) {// This uses binary search

    int start = 0;
    int end = sortedArray.length - 1;
    int mid = sortedArray[(start + end) / 2];


        if (sortedArray[start] > u || sortedArray[end] < I)
            return false;
        else if (sortedArray[start] > I && sortedArray[end] < u)
            return true;

        else {
            // What to do here? I am stuck!

        }
    return false;
    }

    public static void main(String[] args) {
    int size;
    int inum;

    Scanner input = new Scanner(System.in);
    System.out.println("Enter the size of the array: ");
    size = input.nextInt();
    int[] unsortArray = new int[size];

    for (int i = 0; i < size; i++) {
        int c = i + 1;
        System.out.println("Enter element " + c + " to be added to the array: ");
        inum = input.nextInt();
        unsortArray[i] = inum;
    }

    int left = 0;
    int right = size - 1;

    int[] sortedArray = quickSort(unsortArray, left, right);
    int I; // greater than
    int u; // less than

    System.out.println("Enter range starting point: ");
    I = input.nextInt();
    System.out.println("Enter range end point: ");
    u = input.nextInt();

    boolean result = withinRangeSorted(sortedArray, I, u);
    System.out.println(result);
    }
}

import java.util.Scanner；
类RangeBinarySearch{
公共静态int[]快速排序（int[]未排序、int左、int右）{
int[]sortArray=unsortedArray；
如果（左>=右）
返回Sortaray；
int pivot=unsortedArray[（左+右）/2]；
int i=左；
int j=右；
而（我）
j--；
如果（i）
快速排序（未排序的Darray，i，右）；
返回Sortaray；
}
带范围排序的公共静态布尔值（int[]sortedDarray，int I，int u）{//这使用二进制搜索
int start=0；
int end=sortedArray.length-1；
int mid=sortedArray[（开始+结束）/2]；
如果（sortedArray[start]>u | | sortedArray[end]I&&SorterDarray[end]

问题是，我似乎不知道如何使用rangesorted方法构造

如果我搜索的值大于
I
且小于
u
，我主要不知道该方法应该采用哪种类型的参数。
我觉得我在这里走的是对的，但是我似乎不能正确地表达递归

非常感谢您的帮助。
据我所知，数组中的所有整数必须大于
I
，但小于
u
。因此，实现非常简单：

boolean withinRange(int[] array, int lower, int upper) {

    for (int i : array)
        if (i <= lower && i >= upper)
            return false;
    return true;
}

boolean withinRange（int[]数组，int下限，int上限）{
for（int i:array）
如果（i=上限）
返回false；
返回true；
}

我不知道为什么数组需要排序，除非条件是该范围内至少需要1个数字，而不是我所理解的所有数字

但如果您确实需要确定它是否包含指定范围内的数字，则可以使用此简单方法测试该范围内的每个数字（如果该数字存在于数组中）：

boolean containsNumberInRange(int[] array, int lower, int upper) {

    for (int i = lower + 1; i < upper; i++)
        if (Arrays.binarySearch(array, i) >= 0)
            return true;
    return false;
}

boolean containsNumberInRange（int[]数组，int-lower，int-upper）{
对于（int i=lower+1；i=0）
返回true；
返回false；
}

顺便说一句，你不需要自己实现快速排序算法，除非它是作为
数组的家庭作业的一部分。可以使用sort（int[]）
，它在内部使用快速排序。
据我所知，数组中的所有整数必须大于
I
，但小于
u
。因此，实现非常简单：

boolean withinRange(int[] array, int lower, int upper) {

    for (int i : array)
        if (i <= lower && i >= upper)
            return false;
    return true;
}

boolean withinRange（int[]数组，int下限，int上限）{
for（int i:array）
如果（i=上限）
返回false；
返回true；
}

我不知道为什么数组需要排序，除非条件是该范围内至少需要1个数字，而不是我所理解的所有数字

但如果您确实需要确定它是否包含指定范围内的数字，则可以使用此简单方法测试该范围内的每个数字（如果该数字存在于数组中）：

boolean containsNumberInRange(int[] array, int lower, int upper) {

    for (int i = lower + 1; i < upper; i++)
        if (Arrays.binarySearch(array, i) >= 0)
            return true;
    return false;
}

boolean containsNumberInRange（int[]数组，int-lower，int-upper）{
对于（int i=lower+1；i=0）
返回true；
返回false；
}

顺便说一句，你不需要自己实现快速排序算法，除非它是作为
数组的家庭作业的一部分。可以使用sort（int[]）
，它在内部使用快速排序。
据我所知，数组中的所有整数必须大于
I
，但小于
u
。因此，实现非常简单：

boolean withinRange(int[] array, int lower, int upper) {

    for (int i : array)
        if (i <= lower && i >= upper)
            return false;
    return true;
}

boolean withinRange（int[]数组，int下限，int上限）{
for（int i:array）
如果（i=上限）
返回false；
返回true；
}

我不知道为什么数组需要排序，除非条件是该范围内至少需要1个数字，而不是我所理解的所有数字

但如果您确实需要确定它是否包含指定范围内的数字，则可以使用此简单方法测试该范围内的每个数字（如果该数字存在于数组中）：

boolean containsNumberInRange(int[] array, int lower, int upper) {

    for (int i = lower + 1; i < upper; i++)
        if (Arrays.binarySearch(array, i) >= 0)
            return true;
    return false;
}

boolean containsNumberInRange（int[]数组，int-lower，int-upper）{
对于（int i=lower+1；i