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在每次递归调用中覆盖min = a[ i ];，而不是这样做。
您访问数组越界，在i为6时的最后一次函数调用中，运行调用未定义行为的代码[ i + 1 ]。不幸的是，你的程序没有崩溃，而是输出了一些垃圾值。
对于您正在编写的算法，绝对没有理由使用递归。

Answer 3

显示此代码（我在初始函数调用中将初始化min的整数变量static int initialize_min添加为[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。它也必须是不安全的，因为我们可能想要使用无符号，长，长，__ 8等。

递归最小函数

6 个答案: