Java 搜索一个数字在排序数组中出现多少次的最有效方法

我正在寻找一种有效的方法来确定某个数字在排序数组中出现的次数

我当前的代码：

public class Numbers {

    public static void main(String[] args) {
        int[] x = new int[]{1,2,3,4,4,7,7,7,7,7,8};
        int count = 0;
        for (int i = 0; i < x.length; ++i)
            if (x[i] == 7) ++count;
        System.out.println(count);
    }
}

公共类编号{
公共静态void main（字符串[]args）{
int[]x=新的int[]{1,2,3,4,4,7,7,7,8}；
整数计数=0；
对于（int i=0；i

答案实际上取决于阵列的长度，如果阵列只有10个元素，那么进行线性扫描可能更有效。如果是较大的数组，我建议使用

array.binarySearch（）

，如下所示：

public static void main(String[] args) {
    int[] x = new int[]{1,2,3,4,4,7,7,7,7,7,8};
    int index = Arrays.binarySearch(x, 7);
    System.out.println(index);
    int count = 0;
    if (index >= 0) {
        // search down
        int i = index - 1;
        for (; i >= 0 && x[i] == 7; --i) {
        }
        // search up
        for (++index; index < x.length && x[index] == 7; ++index) {
        }
        count = index - (i + 1);
    }
    System.out.println(count);
}

publicstaticvoidmain（字符串[]args）{
int[]x=新的int[]{1,2,3,4,4,7,7,7,8}；
int index=Arrays.binarySearch（x，7）；
系统输出打印项次（索引）；
整数计数=0；
如果（索引>=0）{
//搜寻
int i=指数-1；
对于（；i>=0&&x[i]==7；--i）{
}
//查寻
对于（++index；index

---

首先，二进制搜索将告诉您该项是否存在于数组中，如果存在，您不知道搜索在该范围内的何处找到了元素，但您必须在两个方向上进行线性扫描以确定准确的计数，但是您必须进行的比较数量最多是该特定键的计数。。。（不包括二进制搜索）

答案实际上取决于数组的长度，如果只有10个元素，那么进行线性扫描可能更有效。如果是较大的数组，我建议使用

array.binarySearch（）

，如下所示：

public static void main(String[] args) {
    int[] x = new int[]{1,2,3,4,4,7,7,7,7,7,8};
    int index = Arrays.binarySearch(x, 7);
    System.out.println(index);
    int count = 0;
    if (index >= 0) {
        // search down
        int i = index - 1;
        for (; i >= 0 && x[i] == 7; --i) {
        }
        // search up
        for (++index; index < x.length && x[index] == 7; ++index) {
        }
        count = index - (i + 1);
    }
    System.out.println(count);
}

publicstaticvoidmain（字符串[]args）{
int[]x=新的int[]{1,2,3,4,4,7,7,7,8}；
int index=Arrays.binarySearch（x，7）；
系统输出打印项次（索引）；
整数计数=0；
如果（索引>=0）{
//搜寻
int i=指数-1；
对于（；i>=0&&x[i]==7；--i）{
}
//查寻
对于（++index；index

---

首先，二进制搜索将告诉您该项是否存在于数组中，如果存在，您不知道搜索在该范围内的何处找到了元素，但您必须在两个方向上进行线性扫描以确定准确的计数，但是您必须进行的比较数量最多是该特定键的计数。。。（不包括二进制搜索）

由于数组已排序，如注释中所述，您可以执行2次二进制搜索，以查找数组中出现数字的最低索引和出现数字的最高索引。添加一个二进制搜索来查找一些索引，您将得到一个O（logn）算法

使用一些不同的数组值尝试此代码

public static void main(final String[] args) {
    final int numberToCount = 7;

    final int[] x = new int[]{1,2,3,4,4,6,6,6,6,7,7,7,7,7,8,8,8,8,8,8};

    final int indexOfKnownOccurence = Arrays.binarySearch(x, numberToCount);
    if (indexOfKnownOccurence < 0) {
        System.out.println("No instances of the number found");
        return;
    }

    final int lowerBound = findIndexOfFirstOccurence(x, numberToCount, 0, indexOfKnownOccurence);

    final int upperBound = findIndexOfLastOccurence(x, numberToCount, indexOfKnownOccurence, x.length - 1);

    System.out.println("Lower bound: " + lowerBound);
    System.out.println("Upper bound: " + upperBound);
    System.out.println("Number of occurrences: " + (upperBound - lowerBound + 1));
}

//Binary search for start index
public static int findIndexOfFirstOccurence(final int[] x, final int numberToFind, final int startIndex, final int endIndex) {
    if (startIndex == endIndex) {
        return startIndex;
    } else if (x[startIndex] == numberToFind) {
        return startIndex;
    } else if (startIndex + 1 == endIndex) {
        return endIndex;
    }

    final int midIndex = startIndex + (int)Math.floor((endIndex - startIndex) / 2);

    if (x[midIndex] == numberToFind) {
        return findIndexOfFirstOccurence(x, numberToFind, startIndex, midIndex);
    } else {
        return findIndexOfFirstOccurence(x, numberToFind, midIndex, endIndex);
    }
}

//Binary search for end index
public static int findIndexOfLastOccurence(final int[] x, final int numberToFind, final int startIndex, final int endIndex) {
    if (startIndex == endIndex) {
        return endIndex;
    } else if (x[endIndex] == numberToFind) {
        return endIndex;
    } else if (startIndex + 1 == endIndex) {
        return startIndex;
    }

    final int midIndex = startIndex + (int)Math.floor((endIndex - startIndex) / 2);

    if (x[midIndex] == numberToFind) {
        return findIndexOfLastOccurence(x, numberToFind, midIndex, endIndex);
    } else {
        return findIndexOfLastOccurence(x, numberToFind, startIndex, midIndex);
    }
}

publicstaticvoidmain（最终字符串[]args）{
最终整数计数=7；
final int[]x=新int[]{1,2,3,4,4,6,6,6,7,7,7,8,8,8,8}；
final int indexofknownocurence=Arrays.binarySearch（x，numberToCount）；
如果（索引fknownocurence<0）{
System.out.println（“未找到该编号的实例”）；
回来
}
final int lowerBound=findIndexOfffirstoCurence（x，numberToCount，0，indexOfKnowNoCurence）；
final int upperBound=findIndexOfLastOccurence（x，numberToCount，indexOfKnowNoCurence，x.length-1）；
System.out.println（“下限：+lowerBound”）；
System.out.println（“上限：+上限”）；
System.out.println（“出现次数：+（上限-下限+1））；
}
//开始索引的二进制搜索
公共静态int findIndexOfficerToCurence（final int[]x，final int numberToFind，final int startIndex，final int endIndex）{
if（startIndex==endIndex）{
返回startIndex；
}如果（x[startIndex]==numberToFind）为else，则为{
返回startIndex；
}else if（startIndex+1==endIndex）{
返回端索引；
}
最终int midIndex=startIndex+（int）数学层（（endIndex-startIndex）/2）；
if（x[midIndex]==numberToFind）{
返回findIndexOffirsToCurence（x，numberToFind，startIndex，midIndex）；
}否则{
返回findIndexOffirsToCurence（x，numberToFind，midIndex，endIndex）；
}
}
//结束索引的二进制搜索
公共静态int FindIndexOfLastConcernce（final int[]x，final int numberToFind，final int startIndex，final int endIndex）{
if（startIndex==endIndex）{
返回端索引；
}else if（x[endIndex]==numberToFind）{
返回端索引；
}else if（startIndex+1==endIndex）{
返回startIndex；
}
最终int midIndex=startIndex+（int）数学层（（endIndex-startIndex）/2）；
if（x[midIndex]==numberToFind）{
返回FindIndexoflastReccurrence（x，numberToFind，midIndex，endIndex）；
}否则{
返回FindIndexoflastRecurence（x，numberToFind，startIndex，midIndex）；
}
}

由于数组已排序，如注释中所述，您可以执行2次二进制搜索，以查找数组中出现数字的最低索引和出现数字的最高索引。添加一个二进制搜索来查找一些索引，您将得到一个O（logn）算法

使用一些不同的数组值尝试此代码

public static void main(final String[] args) {
    final int numberToCount = 7;

    final int[] x = new int[]{1,2,3,4,4,6,6,6,6,7,7,7,7,7,8,8,8,8,8,8};

    final int indexOfKnownOccurence = Arrays.binarySearch(x, numberToCount);
    if (indexOfKnownOccurence < 0) {
        System.out.println("No instances of the number found");
        return;
    }

    final int lowerBound = findIndexOfFirstOccurence(x, numberToCount, 0, indexOfKnownOccurence);

    final int upperBound = findIndexOfLastOccurence(x, numberToCount, indexOfKnownOccurence, x.length - 1);

    System.out.println("Lower bound: " + lowerBound);
    System.out.println("Upper bound: " + upperBound);
    System.out.println("Number of occurrences: " + (upperBound - lowerBound + 1));
}

//Binary search for start index
public static int findIndexOfFirstOccurence(final int[] x, final int numberToFind, final int startIndex, final int endIndex) {
    if (startIndex == endIndex) {
        return startIndex;
    } else if (x[startIndex] == numberToFind) {
        return startIndex;
    } else if (startIndex + 1 == endIndex) {
        return endIndex;
    }

    final int midIndex = startIndex + (int)Math.floor((endIndex - startIndex) / 2);

    if (x[midIndex] == numberToFind) {
        return findIndexOfFirstOccurence(x, numberToFind, startIndex, midIndex);
    } else {
        return findIndexOfFirstOccurence(x, numberToFind, midIndex, endIndex);
    }
}

//Binary search for end index
public static int findIndexOfLastOccurence(final int[] x, final int numberToFind, final int startIndex, final int endIndex) {
    if (startIndex == endIndex) {
        return endIndex;
    } else if (x[endIndex] == numberToFind) {
        return endIndex;
    } else if (startIndex + 1 == endIndex) {
        return startIndex;
    }

    final int midIndex = startIndex + (int)Math.floor((endIndex - startIndex) / 2);

    if (x[midIndex] == numberToFind) {
        return findIndexOfLastOccurence(x, numberToFind, midIndex, endIndex);
    } else {
        return findIndexOfLastOccurence(x, numberToFind, startIndex, midIndex);
    }
}

publicstaticvoidmain（最终字符串[]args）{
最终整数计数=7；
final int[]x=新int[]{1,2,3,4,4,6,6,6,7,7,7,8,8,8,8}；
final int indexofknownocurence=Arrays.binarySearch（x，numberToCount）；
如果（索引fknownocurence<0）{
System.out.println（“未找到该编号的实例”）；
回来
}
final int lowerBound=findIndexOfffirstoCurence（x，numberToCount，0，indexOfKnowNoCurence）；
最终int上限=findIndexOfLastOccur