求一个递归算法

[zhoufanking]

在书上看了一道题，没想出来用递归怎么写。题目是这样的：
写一个递归程序，用0，1填充一个n×2^n数组，让这个数组表示所有n位二进制数，如下所示：
0001
0010
0011
……
1111

[tailzhou]

第一个数不是全0000??

最好的方法不需要用递归;一个循环就可以了;

一定要递归的话可以这样:
可以看到
数组的前半部分的第一个元素都是0,后半部分的第一个数都是1;
数组的前半部分的前半部分的第二个元素都是0,数组的前半部分的后半部分第二个元素都是1;
数组的后半部分的前半部分的第二个元素都是0,数组的后半部分的后半部分第二个元素都是1;
......

int a[2^n][n];

void fill(int a[][n],int low,int high,int bit)
{
int mid=(low+high)/2;
int i;
if (bit==n-1)
{
a[low][bit]=0;
a[high][bit]=1;
return;
}
for (i=low;i<=mid;i++)
{
a[i][bit]=0;
}
for (i=mid+1;i<=high;i++)
{
a[i][bit]=1;
}
fill(a,low,nid,bit+1);
fill(a,mid+1,high,bit+1);
}

fill(a,0,2^n-1,0);

[tailzhou]

实际上,数组的前半部分的第一个数都是0,

数组的前半部分的第二个数到第n-1个,即 a[0][1]--a[2^(n-1)-1][n-1]范围内的数字
相当于:
用0，1填充一个(n-1)×2^(n-1)数组，让这个数组表示所有n-1位二进制数

[zhoufanking]

第1个数是全0，我写错了，sorry。这个主要是为了练习递归而用递归。

[Endels]

手头正好有离散数学,这个可以用后续子集算法来解决.如下:

某N位2进制长度的数串为0000..(N个)

WHILE 该数串不为 1111..(N个)
将该数串最右边第一个0改为1,这个0右边的所有1都改为0;
输出该数串;

我个人觉得递归只是一种解决一类问题的手法,象汉诺塔,因为只知道解决问题的方法是可行的而且是机械的,但却不知道结束的条件具体是什么,所以只是重复的使用这种方法.类似的象 卡特兰 记数的问题.象这个问题,用递归似乎太勉强了.

想了一下,如果以上面的算法来看,这个题递归的想法很变态,如下:

string = "1111..."
void BiDeep(&string)
{
if( string == "0000.." ){
printf("0000...\n End \n");
return;
}
else {
将该数串string最右边第一个1改为0,这个1右边的所有0都改为1;//实际就是将上面的算法反过来做
BiDeep(&string);
}
}

可能楼主也比较熟悉那种在参数上修改的习惯了,其实我觉得这跟递归并没有关系,只要知道确定的步骤,而且知道步骤可以得到正确的结果,就可以用递归来解决.如果楼主学习了 树 这一章,也就可以全面理解了.

[lidowx]

用分治法
要求n时的数组只需在n-1时的数组前加0和1就可以了

[lidowx]

贴一下代码：

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

#define MAXN  10
#define MAX2N 1024

int p[MAX2N][MAXN];

int fill(int n)
{
    if ( 1 == n )
    {
        p[1][MAXN-1] = 1;
        return 2;
    }   
    else
    {
        int count = fill(n-1);      
        int count2 = count*2;
        
        // 在 n-1 的数组前加1，已经赋了初值0，所以0就不需要加了
         for ( int i=count;i<count2;i++)
        {
            // 复制一份在 n-1 时填充的数据
             memcpy(&p[i][MAXN-n+1],&p[i-count][MAXN-n+1],(n-1)*sizeof(int));

            // 在 n-1 填充的数据前加填 1
            p[i][MAXN-n] = 1;
        }

        return count2;
    }
}

int main()
{
    // 填充
    fill(MAXN);
    
    // 打印结果
    for( int i=0;i<MAX2N;i++ )
    {
        for( int j=0;j<MAXN;j++)
        {
            printf("%d",p[i][j]);
        }
        printf("\n");
    }

    return 0;
}

[瓶盒]

我认为对N维的状态空间的搜索，只能使用递归的方法，用For或While是办不到的。本题是对2^N的状态空间的搜索，每一维有2种可选状态，使用递归是合适的。

[xiaoc10]

2^N 似乎应该改为：1 << N
哈哈。。

[瓶盒]

int g_Count=0;
int a[2^N][N]={0};
int bit[N]={0};
void recursion(int n){
if(n==0){
for(int i=0;i<N;i++)
a[g_Count][i]=bit[N-1-i];
g_Count++;
return;
}
bit[n-1]=0;
recursion(n-1);
bit[n-1]=1;
recursion(n-1);
};
recursion(N);
感觉这样简洁些

[grellen]

up

[zhangzhiq000]

#include<iostream>
using namespace std;

void f(int *a,int n,int p)
{
if(p==n)
{
for(int i=0;i<n;i++)
cout<<a[i];
cout<<endl;
return;
}
else
{
a[p]=0;
f(a,n,p+1);
a[p]=1;
f(a,n,p+1);
}
}
int main()
{
int *a,n;
cin>>n;
a=new int[n];
f(a,n,0);
system("pause");
}

[huahuahua12]

a[4]={0};
test(int i)
{int k,m;
if(i==4)
{for(k=0;k<4;k++)
printf("%d ",a[k]);
printf("\n");
}
else
for(m=0;m<2;m++){a[i]=m;test(i+1);}
}
main()
{test(0);
}

[huahuahua12]

int main()
{
int *a,n;
cin>>n;
a=new int[n];
test(int i)
{int k,m;
if(i==n)
{for(k=0;k<n;k++)
printf("%d ",a[k]);
printf("\n");
}
else
for(m=0;m <2;m++){a[i]=m;test(i+1);}
}
main()
{test(0);
}

[jy02684358]

为什么不做加法读它的二进制码。

[gygl_4]

我也觉得还是直接对数值的二进制比较简单


那个数组的内存没有动态分配，直接用全局变量固定死了

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <math.h>
#include <conio.h>
char bMatrix[16][4];
void vMatrixProc()
{
    int iCounter;
    char bBit;
    int iTempFlag;
    int iRows;
    int iCols;
    //int iEndNum;
    
    //iEndNum = pow(2, iRows);
    
    iCounter = 0;
    iRows = 0;
    iCols = 0;    
    do
    {        
        iTempFlag = 8;
        while (iTempFlag != 0)
        {
            bBit = (iTempFlag & iCounter) != 0? 1: 0;
            bMatrix[iRows][iCols++] = bBit;
            if (iCols >= 4)
            {
                iRows++;
                iCols = 0;
            }            
            iTempFlag = iTempFlag >> 1;
        } 
        iCounter++; 
    } while(iCounter < 16); 
  
    
} 
int main() 
{ 
    int iFirstNum;
    int iSecondNum;
    
    vMatrixProc();
    
    for (iFirstNum = 0; iFirstNum < 16; iFirstNum++)
    {
        for (iSecondNum = 0; iSecondNum < 4; iSecondNum++)
        {
            printf("%d", bMatrix[iFirstNum][iSecondNum]);
        }
        printf("\n");
    }
    
    system("pause");
    return 0; 
}