Java 算法性能。我能'；我不能解决它

我试图解决一个算法问题，但我认为我的分辨率性能不好。所以如果有人能帮助我，我将非常感激

问题是：我有3个数组A，B，C。我想知道在每个B[I]和C[I]的范围内有多少个元素

Example:
A = [1,3,5,8]
B = [3,8]
C= [7,8]

So for B[0] and C[0] the answer is 2, because 3 and 5 are within range
and for B[1] and C[1] the answer is 1, because 8 are within range

the result has to be an array of [2,1].

Specifications:
B.length == C.length
B[i] <= C[i]

示例：
A=[1,3,5,8]
B=[3,8]
C=[7,8]
对于B[0]和C[0]，答案是2，因为3和5在范围内
对于B[1]和C[1]，答案是1，因为8在范围内
结果必须是[2,1]的数组。
规格：
B.长度==C.长度
B[i]=x&&init==-1）{
init=j；
}
如果（a==y&&end==1）{
end=j；
}
如果（a>y&&end==-1）{
end=j-1；
}
if（init！=-1&&end！=-1）{
打破
}
}
结果[i]=end-init+1；
}
返回结果；
}

---

你们觉得怎么样？

在运行B和C阵列时，可以动态地增加结果[i]

static int[] method(int[] A, int[] B, int[] C)
{
    Arrays.sort(A);
    int[] result = new int[B.length];
    for (int i = 0; i < B.length; i++)
    {
        for (int j = 0; j < A.length; j++)
        {
            int a = A[j];
            if (B[i] <= a && a <= C[i])
            {
                result[i]++;
            }
            else if (a >= C[i])
            {
                break;
            }
        }
    }
    return result;
}

静态int[]方法（int[]A，int[]B，int[]C）
{
数组。排序（A）；
int[]结果=新的int[B.长度]；
for（int i=0；i
public static int[] doTask(int[] A, int[] B, int[] C) {
    // Arrays.sort(A);

    List<Integer> aList = Arrays.stream(A).boxed().collect(Collectors.toList());

    int result[]=new int[B.length];
    for (int i=0; i < B.length; i++) {
        Integer b = B[i];
        Integer c = C[i];
        List<Integer> aList2 = aList.stream().filter(a -> a >= b && a <= c).collect(Collectors.toList());
        result[i] = aList2.size();
    }

    // System.out.println(result);
    return result;
}

公共静态int[]doTask（int[]A，int[]B，int[]C）{
//数组。排序（A）；
List aList=Arrays.stream（A.boxed（）.collect（Collectors.toList（））；
int result[]=新int[B.length]；
for（int i=0；iList aList2=aList.stream（）.filter（a->a>=b&&a最佳程序取决于a和b的大小

如果A与B相比非常大，最好不要对其进行排序。遍历A的所有元素，并针对每个元素检查所有间隔是否包含该元素。这将给出O（len A*len B）的运行时间

另一方面，如果有许多区间，最好对A进行排序，并使用二进制搜索来查找每个区间的开始和结束索引。这将给出O（len A*log（len A）+len B*log（len A））的运行时间.
要给Henry的答案添加一些内容，当有很多数字时，二进制搜索算法是目前为止最好的。而且您的解决方案似乎没有考虑到
a
中的重复值

全功能代码：

static int[] method2(int[] A, int[] B, int[] C) {
    Arrays.sort(A);
    int[] result = new int[B.length];
    for (int i = 0; i < B.length; i++) {
        int posMin = java.util.Arrays.binarySearch(A, B[i]);
        int posMax = java.util.Arrays.binarySearch(A, C[i]);
        if (posMin < 0) { posMin = -(posMin+1);   }
        if (posMax < 0) { posMax = -(posMax+1)-1; }
        result[i] = posMax - posMin +1;
    }
    return result;
}

静态int[]method2（int[]A，int[]B，int[]C）{
数组。排序（A）；
int[]结果=新的int[B.长度]；
for（int i=0；i

从测试中，我用100个间隔和100万个样本进行了测试

方法=16368ms

<2>方法2= 433 MS 
不清楚B[i]和C[i]的“范围”是指什么？B（i）的范围是什么？我们必须考虑“范围”吗？同时计算B和C？你的解决方案有效但速度慢吗？B和C数组的长度是否总是相同的，因为如果不是这样的话，那么它也可能无效？我们的算法的时间复杂度是O（n^2）。我认为一般的想法是返回一个int[]，其中result[I]=A.countElementsBetweenRange（B[I]，C[I]）；数组A、B和C是否已按排序顺序排列？那么你按每个区间对A进行排序？根本没有效率。如果我们要对每个区间同时对所有数组进行排序，然后对新数组进行排序。那么你如何确保不将其他区间的边界计算为数组元素？哦，我的错。---哇，我没有看到你的答案。也许这就是最好的方法。我稍后会试试，然后我会在这里发布。谢谢
1) Concatenate the array A with B[i] & C[i]. i.e
   new array will be [1,3,5,8,3,7]
2) Sort the new array.
   sorted array [1,3,3,5,7,8]
3) filter out the elements between B[i] & C[i] from the array.
   filtered array [3,3,5,7]

static int[] method2(int[] A, int[] B, int[] C) {
    Arrays.sort(A);
    int[] result = new int[B.length];
    for (int i = 0; i < B.length; i++) {
        int posMin = java.util.Arrays.binarySearch(A, B[i]);
        int posMax = java.util.Arrays.binarySearch(A, C[i]);
        if (posMin < 0) { posMin = -(posMin+1);   }
        if (posMax < 0) { posMax = -(posMax+1)-1; }
        result[i] = posMax - posMin +1;
    }
    return result;
}