Question

我想知道是否有可能在非空排序数组中找到可能存在或不存在的元素中最接近的下部元素。元素也可以重复多次。数组+ ve的所有元素。

例如，如果我们有值[2,5,6,7,7,8,9]并且我们正在寻找最接近6的元素，它应该返回5，因为5是最大的数字数组，小于6。类似地，如果我们要查找最接近9的元素，它应该返回8，因为8是数组中的最大数字，小于9。如果找不到最接近的下部元素，则返回-1，就像我们要查找最接近1的元素一样，它应该返回-1，因为没有这样的元素可以低于1.这里 - 图1表示在阵列中不存在最接近元素

的值

我在下面的代码中尝试了这个。没关系？如果我遗失了什么，请帮助我。 Java代码会更有帮助。

static int find(int[] a, int target)
{
    int n = a.length;

    if(target <= a[0])
        return -1;

    if(target > a[n-1])
        return a[n-1];

    int i=0,j=n,mid=0;

    while(i<j)
    {
        mid = (i+j)/2;
        if(target <= a[mid])
        {
            if( mid >0 & target> a[mid-1] )
            {   
                 return a[mid-1]; 
            }

            j= mid;
        }
        else
        {
            if( mid<(n-1) & target > a[mid+1] )
            {   
                 return a[mid+1]; 
            }

            i= mid+1;
        }
    }
    return mid;
}

Answer 1

存在标准的binarySearch函数。

static int find(int[] a, int target) {
    int position = Arrays.binarySearch(a, target);
    if (position >= 0) {
        System.out.println("Found at index " + position);
    } else {
        int insertIndex = ~position;
        System.out.println("Insert position at index " + insertIndex);
        position = insertIndex;
    }
    return position;
}

如果没有找到，则会删除插入位置的补码，如上所示。这意味着当结果为否定时，找不到该项目。

它或多或少地做了你所做的事情，但是如果没有找到，它会巧妙地返回一个否定的：〜插入位置（或者 - 插入位置 - 1）。

/**
 * Search the next smaller array element.
 * @param a the array sorted in ascending order.
 * @param target the value to keep below.
 * @return the greatest smaller element, or -1.
 */
static int findNextSmaller(int[] a, int target) {
    int i= Arrays.binarySearch(a, target);
    if (i >= 0) {
        --i;
        while (i>= 0 && a[i] == target) {
            --i;
        }
    } else {
        i = ~i;
        --i;
    }
    return i == -1 ? -1 : a[i];
}

或者，因为int是离散的：

static int findNextSmaller(int[] a, int target) {
    int i= Arrays.binarySearch(a, target - 1);
    if (i >= 0) {
        return target - 1;
    }
    i = ~i;
    --i;
    return i == -1 ? -1 : a[i];
}

Answer 2

使用流：

import java.util.stream.IntStream;

public class FindNearestLowestValue {

    public final static void main(String[] args) {
        int[] array = {2,5,6,7,7,8,9};
        int searchVal = 6;
        // reverse the order so the first element of the filtered stream is the result
        System.out.println(
            IntStream.range(0, array.length)
                .map(i -> array[array.length - 1 - i])
                .filter(n -> n < searchVal)
                .findFirst().orElse(-1)
        );
    }
}

查找已排序的1D数组中

2 个答案: