笔试题练习（六）

1，输入N, 打印 N*N螺旋矩阵

比如 N = 3，打印：

1 2 3

8 9 4

7 6 5

N = 4，打印：

1   2   3   4

12 13 14 5

11 16 15 6

10 9   8   7

/**
 * 
 *  @author  phinecos
 *  @since  2005-05-27
  */
public   class  test 
{
     private   static   int  n;
     private   static   int [][] array;
     private   static   int  current  =   1 ;

     public   static   void  fill( int  m)
    {
         if  (current  >=  n * n)
        { // 递归结束条件
             return ;
        }
         int  i;
         // 上
         for  (i  =  n - m; i  <  m;  ++ i)
        {
            array[n - m][i]  =  current ++ ;
        }
         // 右
         for  (i  =  n - m + 1 ; i  <  m - 1 ;  ++ i)
        {
            array[i][m - 1 ]  =  current ++ ;
        }
         // 下
         for  (i  =  m - 1 ; i  >=  n - m;  -- i)
        {
            array[m - 1 ][i]  =  current ++ ;
        }
         // 左
         for  (i  =  m - 2 ; i  >=  n - m + 1 ;  -- i)
        {
            array[i][n - m]  =  current ++ ;
        }
         // 进入下一层
        fill(m - 1 );
    }
     public   static   void  main(String[] args)  throws  Exception
    {
        n  =   10 ;
        array  =   new   int  [n][n];
        fill(n);
         if  (n % 2   ==   1 )
        { // 奇数层次，补充中心点
            array[n / 2 ][n / 2 ]  =  n * n;
        }
         for  ( int  i  =   0 ; i  <  n;  ++ i)
        {
             for  ( int  j  =   0 ; j  <  n;  ++ j)
            {
                System.out.print(array[i][j]);
                System.out.print( ' /t ' );
            }
            System.out.println();
        }
    }
}

2，要求：不申请变量和空间反转字符串，用一个函数实现。

第一种解法就是不使用变量交换两个数的两种方法

char *  reverseString( char *  srcStr)
{ // 不申请变量和空间反转字符串
     if  (srcStr  ==  NULL  ||  strlen(srcStr)  ==   0 )
    {
         return  NULL;
    }
     if  (strlen(srcStr)  ==   1 )
         return  srcStr;
     for  ( int  i  =   0 ,j  =  strlen(srcStr) - 1 ; i  <  j ;  ++ i, -- j)
    {
         // 第一种交换方式，可能会溢出
         // srcStr[i] = srcStr[i] + srcStr[j];
         // srcStr[j] = srcStr[i] - srcStr[j];
         // srcStr[i] = srcStr[i] - srcStr[j];
         // 第二种交换方式，可能会溢出
        srcStr[i]  =  srcStr[i]  ^  srcStr[j];
        srcStr[j]  =  srcStr[i]  ^  srcStr[j];
        srcStr[i]  =  srcStr[i]  ^  srcStr[j];
    }
     return  srcStr;
}

第二种方法就是利用空闲的’/0’字符占的位置作为中间变量，最后填补一个’/0’

char *  reverseString( char *  srcStr)
{ // 不申请变量和空间反转字符串
     if  (srcStr  ==  NULL  ||  strlen(srcStr)  ==   0 )
    {
         return  NULL;
    }
     if  (strlen(srcStr)  ==   1 )
         return  srcStr;
     for  ( int  i  =   0 ,j  =  strlen(srcStr) - 1 ; i  <=  j ;  ++ i, -- j)
    {
        srcStr[len]  =  srcStr[i];
        srcStr[i]  =  srcStr[j];
        srcStr[j]  =  srcStr[len];
    }
    srcStr[len]  =   ' /0 ' ;
     return  srcStr;
}

3，把一个32位的数按位反转

unsigned  int  bit_reverse(unsigned  int  n)
{
    n  = ((n  >>   1 ) &   0x55555555 ) | ((n  <<   1 ) &   0xaaaaaaaa );
    n  = ((n  >>   2 ) &   0x33333333 ) | ((n  <<   2 ) &   0xcccccccc );
    n  = ((n  >>   4 ) &   0x0f0f0f0f ) | ((n  <<   4 ) &   0xf0f0f0f0 );
    n  = ((n  >>   8 ) &   0x00ff00ff ) | ((n  <<   8 ) &   0xff00ff00 );
    n  = ((n  >>   16 ) &   0x0000ffff ) | ((n  <<   16 ) &   0xffff0000 ); 
     return  n;
} 

4，将给定的一个整数转换成字符串

char *  IntToString( int  num)
{
     int  count  =   0 ;
     bool  isNegative  =   false ;
     if  (num  <   0 )
    {
        num  =   - 1   *  num;
        isNegative  =   true ;
         ++ count;
    }
     int  tmp  =  num;
     while  (tmp  !=   0 )
    {
         ++ count;
        tmp  /=   10 ;
    }
     char *  result  =   new   char [count + 1 ];
     if  (isNegative  ==   true )
    {
        result[ 0 ]  =   ' - ' ;
    }
     int  i  =  count;
     while  (num  !=   0 )
    {
        result[ -- i]  =  num  %   10   +   ' 0 ' ;
        num  /=   10 ;
    }
    result[count]  =   ' /0 ' ;
     return  result;
}