递归效率与非递归效率

题目1384：二维数组中的查找

时间限制：1 秒

内存限制：32 兆

特殊判题：否

提交：10472

解决：2093

题目描述：

在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

输入：

输入可能包含多个测试样例，对于每个测试案例，

输入的第一行为两个整数m和n(1<=m,n<=1000)：代表将要输入的矩阵的行数和列数。

输入的第二行包括一个整数t(1<=t<=1000000)：代表要查找的数字。

接下来的m行，每行有n个数，代表题目所给出的m行n列的矩阵(矩阵如题目描述所示，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。

输出：

对应每个测试案例，

输出”Yes”代表在二维数组中找到了数字t。

输出”No”代表在二维数组中没有找到数字t。

int JudgeNumberInArray(unsigned int **target_array, int row,int column, unsigned int search_num)
{
    int i = 0,j = column - 1;
    while(i < row && j >= 0 )
    {
        if(search_num == *((unsigned int *)target_array+j))
        {
            return 1;
        }
        else if(search_num > *((unsigned int *)target_array+j))
        {
            i++;
            target_array = (unsigned int **)((unsigned int *)target_array + column);
        }
        else
        {
            j--;
        }
    }
    return 0;
}

时间：710

int JudgeNumberInArray(unsigned int **target_array, int row,int column, unsigned int search_num)
{
    int i = 0,j = column - 1;
    while(i < row && j >= 0 )
    {
        if(search_num == *((unsigned int *)target_array + i*column + j))
        {
            return 1;
        }
        else if(search_num > *((unsigned int *)target_array + i*column + j))
        {
            i++;
            //target_array = (unsigned int **)((unsigned int *)target_array + column-1);
        }
        else
        {
            j--;
        }
    }
    return 0;
}

时间：670

int JudgeNumberInArray(unsigned int **target_array, int row,int column, unsigned int search_num)
{
 
    if(row ==0 || column == 0)
    {
        return 0;
    }
    if(search_num == *((unsigned int *)target_array+column-1))
    {
        return 1;
    }
    else if(search_num > *((unsigned int *)target_array+column-1))
    {
        return JudgeNumberInArray((unsigned int **)((unsigned int *)target_array+column),row-1,column,search_num);
    }
    else
    {
        return JudgeNumberInArray(target_array,row,column-1,search_num);
    }
}

时间：670

规模小时递归效率未必低

#include <stdio.h>
 
typedef unsigned int u_int32_t;
 
u_int32_t recursion(u_int32_t n, u_int32_t *result)
{
    (*result) += n;
    if(1 == n)
        return 1;
    return recursion(n - 1,result);
}
 
int main(int argc,char **argv)
{
    u_int32_t n = 0,result;
    while(scanf("%u",&n) != EOF)
    {
        if(n <= 0)
            return 0;
        result = 0;
        recursion(n,&result);
        printf("%u\n",result);
    }
    return 1;
}

时间：170

#include <stdio.h>
 
typedef unsigned int u_int32_t;
 
u_int32_t recursion(u_int32_t n)
{
    if(1 == n)
        return 1;
    return n + recursion(n - 1);
}
 
int main(int argc,char **argv)
{
    u_int32_t n = 0;
    while(scanf("%u",&n) != EOF)
    {
        if(n <= 0)
            return 0;
        printf("%d\n",recursion(n));
    }
    return 1;
}

时间：120

尾递归优化防止溢出，效率未必提升。(以上代码用了if，仅仅测试使用，不满足题目要求)

#include <stdio.h>
#include <math.h>

#define MAX(a,b) ((a)>(b)?(a):(b))

int f(int x)
{
	int s = 0;
	while(x-->0)
		s += f(x);
	return MAX(s,1);
}

int main(int argc,char **argv)
{
	int x = 0;
	x = f(35);
	printf("%d\n",x);
	return 1;
}

上面代码在虚拟机里面跑了10 分钟还没完。。。

附：target_array分配为全局变量效率劣于一次性分配可能的在栈上分配，劣于根据需要在栈上分配

原因可能是由于局部性原理。