递归最小函数

Question

#include<stdio.h>
#define SIZE 7

int recursiveMinimum( int a[], int size );

int main(void) {
    int a[ SIZE ] = { 5, 7, 4, 3, 5, 1, 3 }; // Number 2 is not initialized.

    printf( "The smallest number is %d", recursiveMinimum( a, SIZE ) );

    return 0;
}

int recursiveMinimum( int a[], int size ) {
    static int min ;
    static int i = 0;

    min = a[ i ];
    if( a[ i + 1 ] < min ) {
        min = a[ i + 1 ];
    }

    i++;

    if( i == size  ) {
        return min;
    } else {
       return recursiveMinimum( a, size  );
    }
}

那为什么要打印2？

Answer 1

您对数组具有非逐一访问权限：您正在访问 a[7] 元素，但数组的最后一个元素是 a[6]。

看看你有：

i++;
if( i == size  ) {

但在上面您访问的是a[i + 1]，这意味着在某些时候您将访问a[size]（在数组之外）。

将if (i == size) 更改为if (i == size - 1) 以解决您的问题。

Answer 2

• 您没有正确初始化min，它需要设置为它可以拥有的最小可能数字，例如limits.h 中的常量INT_MIN。您无需这样做，而是在每个递归调用中使用 min = a[ i ]; 行覆盖 min。
• 当i 为6 时，您访问数组越界，在最后一次函数调用中，您运行代码[ i + 1 ]，它会调用未定义的行为。不幸的是，您的程序没有崩溃，而是输出了一些垃圾值。
• 绝对没有理由对您正在编写的这个算法使用递归。

Answer 3

显示此代码（我在第一个函数调用中添加整数变量 static int initialize_min 作为初始化 min 作为 a[0]）：

#include<stdio.h>
#define SIZE 7

int recursiveMinimum( int a[], int size );

int main(void) {
    int a[ SIZE ] = { 5, 7, 4, 3, 5, 1, 3 }; // Number 2 is not initialized.

    printf( "The smallest number is %d", recursiveMinimum( a, SIZE ) );

    return 0;
}

int recursiveMinimum( int a[], int size ) {
    static int min;
    static int initialize_min = 1;
    static int i = 0;


    if(initialize_min )
    {
        min = a[0];
        initialize_min = 0;
    }



    if( a[ i ] < min ) {
        min = a[ i ];
    }

    i++;

    if( i == size  ) {
        return min;
    } else {
       return recursiveMinimum( a, size  );
    }
}

Answer 4

我认为这个例子是用于递归最小函数的：

#include <stdio.h>
#define SIZE 7

#define min(a, b)  (((a) < (b)) ? (a) : (b))

/*      assumes size != 0 */
int recursiveMinimum(int a[], size_t size){
int *beg;               /* ptr to beginning */
int *mid;               /* ptr to middle */
int *end;               /* ptr to end */
    if(size < 2)        /* if size == 1 */
        return a[0];
    beg = &a[0];        /* else split array */
    mid = &a[size/2];   /*  and recurse */
    end = &a[size];
    return min(recursiveMinimum(beg, mid-beg),
               recursiveMinimum(mid, end-mid));
}

int main(void)
{
    int a[SIZE] = {5, 7, 4, 3, 5, 1, 3 };
    printf( "The smallest number is %d", recursiveMinimum( a, SIZE ) );
    return 0;
}

Answer 5

你可以试试这个方法：

double smaller(double a, double b){
  return (a<b)?a:b;
}

double min(double *p_array, int idx_low, int idx_high){
  if(idx_low==idx_high)
     return p_array[idx_low];
  int idx_mid=idx_low+(idx_high-idx_low)/2;
  return smaller(min(p_array,idx_low,idx_mid), min(p_array,idx_mid+1, idx_high));
}

对算法的分析应该会给你一个 O(n*log(n)) 运行时间 - 不过，请注意。

Answer 6

要使用 INT_MIN，我们应该包含 limits.h。 它也一定是不安全的，因为我们可能想要使用 unsigned、long、long long、__int8 等。