二分查找的递归函数

Question

创建用于二分搜索的递归函数。
此函数接受一个排序数组和一个要搜索的项目，并返回该项目的索引（如果项目在数组中），或者返回 -1（如果项目不在数组中）。
此外，编写一个测试程序来测试你的功能。

template <class elemType>
int orderedArrayListType<elemType>::binarysearch
                                (const elemType& item) const
{
    int first= 0;
    int last = length -1;
    int mid;
    int list[];
    int BinarySearch(,Type & Item, int first, int last)
    bool found = false;
    while (first <= last && !found){
        mid = (first + last) / 2;
        if (list[mid] > item)
            return BinarySearch(list, item, first, mid -1)
        found = true;
        else if (list[mid] > item)
            return BinarySearch( list, item, first, mid -1)
            last = mid - 1;
        else 
            first = mid + 1;
    }
    if (found)
        return mid;
    else 
        return -1;
}

Answer 1

在美国有一种儿童游戏，一个孩子选择 1 到 10 之间的一个数字，另一个孩子必须猜出这个数字。如果他们猜错了，第一个孩子就会说“更高”或“更低”。

大多数孩子一开始都是随机猜测，平均需要尝试 4-5 次才能成功。我意识到（这可能就是我最终选择计算机科学的原因），最好的办法是选择中间点（5.5，所以选择 5 或 6。我会选择 5。）。根据他们的说法（“更高”或“更低”），选择一个新范围：1-4 或 6-10。选择该范围中间的数字（2 或 8）。继续将范围分成两半，直到得到数字。

这是对排序数组的二分查找（排序数组是从 1 到 10 的数字）。

要在代码中实现这一点，只需继续执行上述相同的过程即可。选择范围的中点，并根据答案创建一个新范围。

这是一个Java 中的解决方案 递归地执行此操作：

public class BinarySearchRecursive
{
    public static final int NOT_FOUND = -1;

    /**
     * Performs the standard binary search
     * using two comparisons per level.
     * This is a driver that calls the recursive method.
     * @return index where item is found or NOT_FOUND if not found.
     */
    public static int binarySearch( Comparable [ ] a, Comparable x )
    {
        return binarySearch( a, x, 0, a.length -1 );
    }

    /**
     * Hidden recursive routine.
     */
    private static int binarySearch( Comparable [ ] a, Comparable x,
                                     int low, int high )
    {
        if( low > high )
            return NOT_FOUND;

        int mid = ( low + high ) / 2;

        if( a[ mid ].compareTo( x ) < 0 )
            return binarySearch( a, x, mid + 1, high );
        else if( a[ mid ].compareTo( x ) > 0 )
            return binarySearch( a, x, low, mid - 1 );
        else
            return mid;
    }

    // Test program
    public static void main( String [ ] args )
    {
        int SIZE = 8;
        Comparable [ ] a = new Integer [ SIZE ];


    for( int i = 0; i < SIZE; i++ )
        a[ i ] = new Integer( i * 2 );

    for( int i = 0; i < SIZE * 2; i++ )
        System.out.println( "Found " + i + " at " +
                                 binarySearch( a, new Integer( i ) ) );
    }
}

Answer 2

您还可以google“递归二分搜索”和瞧！

编辑-维基百科知道一切（特别是当涉及到cs时）：

最直接的
[二分搜索算法]的实现是递归的，其中
递归搜索子范围
由比较决定：

   BinarySearch(A[0..N-1], value, low, high) {
       if (high < low)
           return -1 // not found
       mid = low + ((high - low) / 2) 
       if (A[mid] > value)
           return BinarySearch(A, value, low, mid-1)
       else if (A[mid] < value)
           return BinarySearch(A, value, mid+1, high)
       else
           return mid // found
   }

Answer 3

只需使用 std::binary_search 即可。告诉导师，函数实际上是在 your_favorite_compiler 中递归实现的。