一些基本算法的遞歸實現

問題描述：

遞歸是計算機科學中最偉大的思想。按照我的理解，所謂遞歸就是把問題化約爲比自身維度更小的問題，直至邊界點（base condition)，

然後利用邊界點的解的結果（相對容易得到）和一定規則回退得到最終所需要的結果。

        常用到的遞歸思想的可歸類爲：

1. 各種tree construct 的操作：遍歷（inorder, preorder, postorder)，深度優先搜索（dfs)，廣度優先搜索（bfs)，插入，刪除，返回最值等；

        2. 各種搜索問題最終都能化約爲遞歸問題。比如八皇后，排列，組合，揹包等等；

3. 下面我嘗試用遞歸思想實現一些平時最常用的操作（比如加法，乘法等）：

代碼如下：

int max( int a, int  b )
{
    if( a  > b )
        return a;
    
    return b;
}

int min( int a, int b )
{
    if( a < b )
        return a;
    
    return b;
}

int Add( int m, int n )
{
    if( 0 == n )
        return 0;
    
    return Add( m + 1, n - 1);
}

int Mutiple( int m, int n )
{
    if( 1 == n )
    {
        return m;
    }
    
    return Mutiple( m + m, n - 1 )
}

int Subtract( int m, int n )
{
    if( 0 == n )
    {
        return 0;
    }
    
    return Subtract( m - 1, n - 1 );
}

int findMax( int* items, int idx, int size )
{
    if( idx == size - 1)
        return items[idx];
    
    return max(  findMax( items, idx + 1, size ), items[idx] );
}

int findMin( int* items, int idx, int size )
{
    if( idx == size - 1 )
        return items[idx];
    
    return min( findMin( items, idx + 1, size ), items[idx] );
}

int Search( int* items, int idx, int size, int val )
{
    if( idx >= size )
        return -1;
    
    if( items[idx] == val )
        return idx;
    
    return Search( items, idx + 1, size, val );
}

int BinarySearch( int* items, int begin, int end, int val )
{
    if( begin > end )
        return -1;
    
    int mid = begin + ( ( end - begin ) >> 1 );
    if( items[mid] > val )
    {
        return BinarySearch( items, begin, mid - 1, val );
    }
    else if( items[mi] < val )
    {
        return BinarySearch( items, mid + 1, end, val );
    }
    else
    {
        return mid;
    }
}

int gcd( int n, int m )
{
    if( 0 == m )
        return n;
    
    return gcd( m, n % m );
}

int fibonical( int n )
{
    if( 1  == n )
        return 1;
    
    return fibonical( n - 1 ) + fibonical( n - 2 );
}

int fictional( int n )
{
    if( 1 == n )
        return n;
    
    return n * fictional( n - 1 );
}

unsigned int power( int n, int m )
{
    if( 1 == m )
        return n;
    
    return power( n * m, m - 1 );
}


unsigned int powerQuick( int n, int m )
{
    if( 1 == m )
        return n;
    
    unsigned int k = powerQuick( n, m / 2 );
    
    if( 0 == m % 2 )
    {
        return k * k;
    }
    else
    {
        return k * k * powerQuick( n, 1 );
    }
    
}



unsigned int Fib( int n, unsigned int a, unsigned int b )
{
    if( 1 == n )
        return b;
    
    return Fib( n - 1, b, a + b );
}


void EulerLetter( int n, int depth, int* result )
{
    if( depth == n )
    {
        for( int i = 0; i < dpeth; i++ )
        {
            printf( "%d ", result[i] );
        }
        
        printf( "\n" );
    
        return;
    }
    
    
    for( int i = 0; i < n; i++ )
    {
        if( depth != i )
        {
            result[depth] = i;
            EulerLetter( n, depth + 1, result );
        }
    }
}