Question

因此，如果排序整数数组包含大于true但小于I的数字，那么我实现了一个返回u的程序的问题，{ {1}}否则。

我已经确定快速排序算法是对数组进行排序的好方法，因为我无法知道用户将如何输入 - 然后，我将排序后的数组提供给二进制搜索并找出数组是否包含指定范围内的整数。问题是，我似乎无法推断这一点，因为它不是我想在这里找到的一个值，而是一个范围。另外，如果可能的话，我想以递归方式实现它。

这是我到目前为止所拥有的：

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); } }方法。

如果我搜索的值大于withinRangeSorted且小于I，我对该方法应该采用何种参数感到困惑。我觉得我在这里走在正确的轨道上，但我似乎无法正确地制定递归。

非常感谢任何帮助。

Answer 1

您只需在二进制搜索期间根据范围检查调整数组边界。我很确定这些参数应该是l（更低）和u（更高）。请注意，我始终将范围视为包含 - 排他性。

/**
 * Whether array has at least one element x such that l <= x < u.
 */
boolean withinRangeSorted (int[] array, int l, int u) {
    int start = 0;
    int end = array.length;
    while (start < end) {
        int current = (start + end) / 2;
        if (array[current] >= u) {
            end = current;
        } else if (array[current] < l) {
            start = current + 1;
        } else {
            return true;
        }
    }
    return false;
}

如果要将其转换为递归实现，请使用start和end作为递归帮助程序的参数。如果您希望范围不是包含性的，请调整<，<=等和+ 1，但要检查是否有错误。

Answer 2

据我所知，数组中的所有整数必须大于i但小于u。所以实现很简单：

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

    for (int i : array)
        if (i <= lower && i >= upper)
            return false;
    return 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;
}

顺便说一下，你不需要自己实现快速排序算法，除非它是家庭作业的一部分，因为可以使用Arrays.sort(int[])而不是内部使用快速排序。

Answer 3

您可以简单地尝试回顾不同的可能性：

// assuming ascending order   
boolean isWithinRange (int [] sortedArray, int min, int max)
{
    int minArr, maxArr;

    minArr = sortedArray [0];

    maxArr = sortedArray [sortedArray.length-1];

    // xxxx..[oooo].. OR  ..[oooo]..xxxx
    if (minArr > max || maxArr < min) return false;

    // ..xx[xxxx]xx..
    if (minArr >= min && maxArr <= max) return true;

    // ..xx[xxooo]..
    if (minArr >= min && minArr <= max) return true;

    // ..[oooxx]xx..
    if (maxArr >= min && maxArr <= max) return true;

    return false;
}

Answer 4

如果只有少量此类查询，最好进行完整搜索。我们不需要对数组进行排序。但是，如果有很多此类查询，我们希望有效地执行这些查询，这个问题有一个简单的O(logn)算法。使用二分搜索，我们可以找到值为> = u的第一个索引。类似地，通过进行另一个二分搜索，我们可以找到第一个索引＆gt; = l。如果两个索引相同，请检查它否则返回true。

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

4 个答案: