具有類返回類型的方法

Question

我不太明白我將如何實現和解決這個問題：

考慮一個按排序順序排列的 n 個數值的數組數據和一個數值目標值列表（目標值不一定要排序）。 您的目標是計算包含所有目標值的最小數組索引范圍。 如果目標值小於 data[0]，則范圍應從 -1 開始。 如果目標值大於 data[n - 1]，則范圍應以 n 結尾。

例如，給定數組 [ 5 8 10 13 15 20 22 26] 和目標值 (8, 2, 9, 17)，范圍是 -1 到 5。

1. 設計一個有效的算法來解決這個問題並在

   public static <T extends Comparable<? super T>> Interval findInterval(T[] sortedData, List<T> targetValues)

   其中Interval是一個類，它提供了兩個公共方法getLower()和getUpper()來返回Interval對象的下getUpper()和上getUpper() 。 實現Interval類。

我理解問題的算法。 但是，我很困惑我將如何實施它。 例如Interval findInterval方法的返回值是什么？

和“實現Interval類”。 我不明白getLower()和getUpper()方法究竟應該返回什么或什么類型。

我希望有人能給我一個想法，我將如何實現這一點。

Answer 1

乍一看， Interval應該只是一個保存計算結果的數據結構。 因此， getLower和getUpper不會動態執行這些計算。

這種數據結構的一個例子可能是：

public final class Interval {
   private final int lower;
   private final int upper;

   public Interval(int lower, int upper) {
       // Check preconditions, like lower can't be < -1, etc.
       this.lower = lower;
       this.upper = upper;
   }

   public int getLower() { return lower; }
   public int getUpper() { return upper; }
}

我認為最有效的算法是O(log n + m)假設n排序數據和m目標值。

1. 首先，您必須在tagetValues找到最低和最高值。 這可以在O(m)通過在循環所有元素時保持lowest和highest變量最新來完成。

2. 然后，你可以做2個后續的二進制搜索sortedData找到從較低的指數lowest ，然后從最高指數highest 。 這將花費2 log n簡化為O(log n) 。

---

完整實現示例：

import java.util.List;
import java.util.Arrays;

public class FindInterval {
  public static void main(String[] args) {
    Integer[] data = new Integer[] {5, 8, 10, 13, 15, 20, 22, 26};
    List<Integer> targets = Arrays.asList(8, 2, 9, 17);
    
    Interval interval = findInterval(data, targets);
    
    System.out.println(interval);
  }
  
  public static <T extends Comparable<? super T>> Interval findInterval(
    T[] sortedData, 
    List<T> targetValues
  ) {
    if (targetValues.isEmpty()) {
      throw new IllegalArgumentException("'targetValues' must not be empty.");
    }
    
    List<T> targetBounds = findTargetBounds(targetValues);

    int lower = Arrays.binarySearch(sortedData, targetBounds.get(0));    
    if (lower < 0 && lower != -1) {
      lower = Math.abs(lower) - 2;
    }
    
    int upper = Arrays.binarySearch(sortedData, targetBounds.get(1));
    if (upper < 0) {
      upper = Math.abs(upper) - 1;
    }
    
    return Interval.of(lower, upper);
  }
  
  private static <T extends Comparable<? super T>> List<T> findTargetBounds(List<T> targetValues) {
    T lower = targetValues.get(0);
    T upper = targetValues.get(0);
    
    for (T value : targetValues) {
      if (value.compareTo(lower) == -1) lower = value;
      if (value.compareTo(upper) == 1) upper = value;
    }
    
    return Arrays.asList(lower, upper);
  }
  
  private final static class Interval {
    private final int lower;
    private final int upper;
    
    private Interval(int lower, int upper) {
      // Check preconditions, like lower can't be < -1, etc.
      this.lower = lower;
      this.upper = upper;
    }
    
    public int getLower() { return lower; }
    public int getUpper() { return upper; }
    
    @Override
    public String toString() {
      return "[" + lower + "," + upper + "]";
    }
    
    public static Interval of(int lower, int upper) {
      return new Interval(lower, upper);
    }
  }
    
}

Answer 2

據我所知， getLower()意味着返回較低的范圍，而getUpper()意味着返回較高的范圍。 因此，對於給出的示例： getLower() -> -1和getUpper() -> 5 。

至於返回一個類，你可以簡單地在你的方法中做這樣的事情：

public static <T extends Comparable<? super T>>
Interval findInterval(T[] sortedData, List<T> targetValues) {
   ...
   return new Interval(...);
}

這回答了你的問題了嗎？