C中的二进制搜索一直返回FALSE

Question

所以我根据维基百科伪代码用 C 语言编写了一个二进制搜索程序，但即使在处理只有一个元素的数组时它也会一直返回 false。我不知道哪里出了问题。任何帮助表示赞赏！顺便说一句，这是一个编码挑战，所以我没有自己编写测试套件。

编辑：功能正在测试如下：

int arr[] = {6};
size_t length = sizeof(arr)/sizeof(*arr);
TEST_ASSER((&arr[0] == binary_search(6, arr, length));


int *binary_search(int value, const int *arr, size_t length) {
    int L = 0;
    int R = length - 1;
    static int m;
    while(L <= R) {
        m = floor((L + R) / 2);
        if(arr[m] < value) {
            L = m + 1;
        } else if(arr[m] > value) {
            R = m - 1;
        } else { return (&m); }
    }
    return 0;
} 

编辑：因此，在我从原始函数中删除了 const 项后，它与以下代码一起使用。感谢大家的帮助！

int *binary_search(int value, int *arr, size_t length) {
    int L = 0;
    int R = length - 1;
    static int m;
    while(L <= R) {
        m = (L + R) / 2; // no floor needed
        if(arr[m] < value) {
            L = m + 1;
        } else if(arr[m] > value) {
            R = m - 1;
        } else {
            return &arr[m];
        }
    }
    return 0; // not found
}

Answer 1

数组的长度被声明为具有size_t的类型

int *binary_search(int value, const int *arr, size_t length) {

因此，在函数中，变量L、R 和m 也应声明为具有size_t 类型。

也使用函数 floor

m = floor((L + R) / 2);

绝对没有意义，因为表达式(L + R) / 2 具有整数类型int。

将变量m 声明为静态也没有多大意义。

函数应该返回找到的元素在数组中的位置，或者如果没有找到这样的元素，则返回数组的大小。

在这种情况下

TEST_ASSER((&arr[0] == binary_search(6, arr, length));

将数组arr的第一个元素的地址与静态局部变量m的地址进行比较。很明显，这些对象占用不同程度的内存。因此，条件将始终评估为逻辑假。

函数可以声明一个定义，例如下面的演示程序所示。

#include <stdio.h>

size_t binary_search( const int a[], size_t n, int value )
{
    size_t low = 0, high = n;
    
    while ( low < high )
    {
        size_t middle = low + ( high - low ) / 2;
        
        if ( value < a[middle] )
        {
            high = middle;
        }
        else if ( a[middle] < value )
        {
            low = middle + 1;
        }
        else
        {
            return middle;
        }
    }
    
    return n;
}

int main(void) 
{
    int a[] = { 6 };
    const size_t N = sizeof( a ) / sizeof( *a );
    
    int value = 6;
    
    size_t pos = binary_search( a, N, value );
    
    if ( pos != N )
    {
        printf( "The value %d is found at position %zu\n", value, pos );
    }
    else
    {
        printf( "The value %d is not found.\n", value );
    }
    
    value = 5;
    
    pos = binary_search( a, N, value );
    
    if ( pos != N )
    {
        printf( "The value %d is found at position %zu\n", value, pos );
    }
    else
    {
        printf( "The value %d is not found.\n", value );
    }
    
    value = 7;
    
    pos = binary_search( a, N, value );
    
    if ( pos != N )
    {
        printf( "The value %d is found at position %zu\n", value, pos );
    }
    else
    {
        printf( "The value %d is not found.\n", value );
    }
    
    return 0;
}

程序输出是

The value 6 is found at position 0
The value 5 is not found.
The value 7 is not found

另一种方法是定义函数，使其返回指向数组中找到的元素的指针，如果找不到这样的元素，则返回 NULL。

这里还有一个演示程序。

#include <stdio.h>

int * binary_search( const int a[], size_t n, int value )
{
    size_t low = 0, high = n;
    
    while ( low < high )
    {
        size_t middle = low + ( high - low ) / 2;
        
        if ( value < a[middle] )
        {
            high = middle;
        }
        else if ( a[middle] < value )
        {
            low = middle + 1;
        }
        else
        {
            return ( int * )( a + middle );
        }
    }
    
    return NULL;
}

int main(void) 
{
    int a[] = { 6 };
    const size_t N = sizeof( a ) / sizeof( *a );
    
    int value = 6;
    
    int *pos = binary_search( a, N, value );
    
    if ( pos != NULL )
    {
        printf( "The value %d is found at position %tu\n", value, pos - a );
    }
    else
    {
        printf( "The value %d is not found.\n", value );
    }
    
    value = 5;
    
    pos = binary_search( a, N, value );
    
    if ( pos != NULL )
    {
        printf( "The value %d is found at position %tu\n", value, pos - a );
    }
    else
    {
        printf( "The value %d is not found.\n", value );
    }
    
    value = 7;
    
    pos = binary_search( a, N, value );
    
    if ( pos != NULL )
    {
        printf( "The value %d is found at position %tu\n", value, pos - a );
    }
    else
    {
        printf( "The value %d is not found.\n", value );
    }
    
    return 0;
}

程序输出同上图。

The value 6 is found at position 0
The value 5 is not found.
The value 7 is not found.

Answer 2

二分查找的逻辑应该是这样的

int *binary_search(int value, const int *arr, size_t length) {
        int L = 0;
        int R = length - 1;
        static int m;
        while(L <= R) {
          m = floor((L + R) / 2);
          if(arr[m]==value)
          {
          // element found
          }
           else if(arr[m] < value) {
                L = m + 1;
            } else if(arr[m] > value) {
                R = m - 1;
            } 
        }
        return 0;
    } 

如果执行了while循环并且没有进入if(arr[m]==value)内部意味着元素不在列表中

Answer 3

您的return 语句返回一个局部变量的地址：&m。这绝对是错误的，因为在函数返回后不再分配此内存，而且它肯定不是您拥有的驱动程序代码中预期的地址。

快速解决方法是return &arr[m]，但是就像在cmets中所说的那样，返回数组元素的地址很奇怪。

只需返回索引，并相应地调整函数返回类型，以及驱动代码：

#include <stdio.h>


int binary_search(int value, const int *arr, size_t length) {
    int L = 0;
    int R = length - 1;
    static int m;
    while(L <= R) {
        m = (L + R) / 2; // no floor needed
        if(arr[m] < value) {
            L = m + 1;
        } else if(arr[m] > value) {
            R = m - 1;
        } else {
            return m;
        }
    }
    return -1; // not found
}

int main(void) {
    printf("Hello World\n");
    int arr[] = {6, 9, 13, 25};
    size_t length = sizeof(arr)/sizeof(*arr);
    if (1 == binary_search(6, arr, length)) {
        printf("ok!\n");
    }

    return 0;
}