web-dev-qa-db-ja.com

ソートされたリストで最も近い/最も近い値を見つける

ある要素のListで最も近い要素を見つけることができるかどうか疑問に思いましたそれはありませんそこにあります。

たとえば、値が[1,3,6,7]で、4に最も近い要素を探している場合、3が返されます。これは、3が配列内の最大の数値であり、4より小さいためです。

英語は私の母国語ではないので、私はそれが理にかなっていると思います。

javalogic
14
drBet

配列がソートされている場合は、O( log n )で変更されたバイナリ検索を実行できます。

    public static int search(int value, int[] a) {

        if(value < a[0]) {
            return a[0];
        }
        if(value > a[a.length-1]) {
            return a[a.length-1];
        }

        int lo = 0;
        int hi = a.length - 1;

        while (lo <= hi) {
            int mid = (hi + lo) / 2;

            if (value < a[mid]) {
                hi = mid - 1;
            } else if (value > a[mid]) {
                lo = mid + 1;
            } else {
                return a[mid];
            }
        }
        // lo == hi + 1
        return (a[lo] - value) < (value - a[hi]) ? a[lo] : a[hi];
    }
31
David Soroko

Array.binarySearch、 docs が必要です。

戻り値：検索キーのインデックス（配列に含まれている場合）。それ以外の場合は、（-（挿入ポイント）-1）。挿入ポイントは、キーが配列に挿入されるポイントとして定義されます。キーより大きい最初の要素のインデックス、または配列内のすべての要素が指定されたキーより小さい場合はa.lengthです。

14
Andrey

NavigableSet、特にhigherとlowerの使用を検討してください。

5
Steve Kuo

バイナリ検索を使用した、わ​​かりやすい別のO（log n）ソリューション：

public class Solution {
    static int findClosest(int arr[], int n, int target)
    {
        int l=0, h=n-1, diff=Integer.MAX_VALUE, val=arr[0];
        while(l<=h)
        {
            int mid=l+(h-l)/2;
            if(Math.abs(target-arr[mid])<diff)
            {
                diff= Math.abs(target-arr[mid]);
                val=arr[mid];
            }
            if(arr[mid]<target)
                l=mid+1;
            else
                h=mid-1;
        }
        return val;

    }

    public static void main(String[] args) {
        System.out.println(findClosest(new int[]{1,3,6,7}, 4, 3));
    }
}
0
NewUser

頭の上から考えると、並べ替えられたリストで最も近い値をすべて見つける必要がある場合は、a最も近い値を見つけて、ターゲットから同じ距離にあるすべての値を見つけることができます。ここでは、バイナリ検索を3回使用しています。

  • 最初に見つけるa最も近い値
  • 左端の最も近い値を見つける2番目
  • 右から最も近い値を見つけるための3番目

Pythonの場合：

def closest_value(arr, target):
  def helper(arr, target, lo, hi, closest_so_far):
    # Edge case
    if lo == hi:
      mid = lo
      if abs(arr[mid] - target) < abs(arr[closest_so_far] - target):
        closest_so_far = mid
      return closest_so_far

    # General case
    mid = ((hi - lo) >> 1) + lo

    if arr[mid] == target:
      return mid

    if abs(arr[mid] - target) < abs(arr[closest_so_far] - target):
      closest_so_far = mid

    if arr[mid] < target:
      # Search right
      return helper(arr, target, min(mid + 1, hi), hi, closest_so_far)
    else:
      # Search left
      return helper(arr, target, lo, max(mid - 1, lo), closest_so_far)


  if len(arr) == 0:
    return -1
  return helper(arr, target, 0, len(arr) - 1, arr[0])


arr = [0, 10, 14, 27, 28, 30, 47]

attempt = closest_value(arr, 26)
print(attempt, arr[attempt])
assert attempt == 3

attempt = closest_value(arr, 29)
print(attempt, arr[attempt])
assert attempt in (4, 5)


def closest_values(arr, target):
  def left_helper(arr, target, abs_diff, lo, hi):
    # Base case
    if lo == hi:
      diff = arr[lo] - target
      if abs(diff) == abs_diff:
        return lo
      else:
        return lo + 1

    # General case
    mid = ((hi - lo) >> 1) + lo
    diff = arr[mid] - target
    if diff < 0 and abs(diff) > abs_diff:
      # Search right
      return left_helper(arr, target, abs_diff, min(mid + 1, hi), hi)
    Elif abs(diff) == abs_diff:
      # Search left
      return left_helper(arr, target, abs_diff, lo, max(mid - 1, lo))
    else:
      # Search left
      return left_helper(arr, target, abs_diff, lo, max(mid - 1, lo))


  def right_helper(arr, target, abs_diff, lo, hi):
    # Base case
    if lo == hi:
      diff = arr[lo] - target
      if abs(diff) == abs_diff:
        return lo
      else:
        return lo - 1

    # General case
    mid = ((hi - lo) >> 1) + lo
    diff = arr[mid] - target
    if diff < 0 and abs(diff) > abs_diff:
      # Search right
      return right_helper(arr, target, abs_diff, min(mid + 1, hi), hi)
    Elif abs(diff) == abs_diff:
      # Search right
      return right_helper(arr, target, abs_diff, min(mid + 1, hi), hi)
    else:
      # Search left
      return right_helper(arr, target, abs_diff, lo, max(mid - 1, lo))


  a_closest_value = closest_value(arr, target)
  if a_closest_value == -1:
    return -1, -1

  n = len(arr)
  abs_diff = abs(arr[a_closest_value] - target)
  left = left_helper(arr, target, abs_diff, 0, a_closest_value)
  right = right_helper(arr, target, abs_diff, a_closest_value, n - 1)
  return left, right


arr = [0, 10, 14, 27, 27, 29, 30]

attempt = closest_values(arr, 28)
print(attempt, arr[attempt[0] : attempt[1] + 1])
assert attempt == (3, 5)

attempt = closest_values(arr, 27)
print(attempt, arr[attempt[0] : attempt[1] + 1])
assert attempt == (3, 4)
0
richizy

最も簡単な方法は、ソートされたリストを反復して、各項目をチェックすることです。

List<Integer> ints = new ArrayList<>();
ints.add(1);
ints.add(3);
ints.add(6);
ints.add(7);

Collections.sort(ints);

int target = 4;
int nearest = 0;

for (int i : ints)
{
    if (i <= target) {
        nearest = i;
    }
}

System.out.println(nearest);

これは、target以下のリスト内の最大の項目を出力します。

0
starf

アンドレイの答えは正しいです。少し拡大します。
組み込みのバイナリ検索を使用できる場合、ホイールを再発明する必要はありません。

あなたはインデックスを見つけることができます：

_int leftIndex = (-Collections.binarySearch(allItems, key) - 2);
int rightIndex = (-Collections.binarySearch(allItems, key) - 1);
_

リストの項目は Comparable を実装する必要があります。 StringやIntegerのような単純な型はすでにこれを実装しています。次に例を示します https://www.javatpoint.com/Comparable-interface-in-collection-framework 。

ユースケースによっては、安全のためにバイナリ検索後にindex = Math.max(0, index)を実行することもできます。

0
Markymark