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

  1. /**  
  2.  *   
  3.  * @author phinecos  
  4.  * @since 2005-05-27  
  5.  */ 
  6. public class test   
  7. {  
  8.     private static int n;  
  9.     private static int[][] array;  
  10.     private static int current = 1;  
  11.  
  12.     public static void fill(int m)  
  13.     {  
  14.         if (current >= n*n)  
  15.         {//递归结束条件  
  16.             return;  
  17.         }  
  18.         int i;  
  19.         //上  
  20.         for (i = n-m; i < m; ++i)  
  21.         {  
  22.             array[n-m][i] = current++;  
  23.         }  
  24.         //右  
  25.         for (i = n-m+1; i < m-1; ++i)  
  26.         {  
  27.             array[i][m-1] = current++;  
  28.         }  
  29.         //下  
  30.         for (i = m-1; i >= n-m; --i)  
  31.         {  
  32.             array[m-1][i] = current++;  
  33.         }  
  34.         //左  
  35.         for (i = m-2; i >= n-m+1; --i)  
  36.         {  
  37.             array[i][n-m] = current++;  
  38.         }  
  39.         //进入下一层  
  40.         fill(m-1);  
  41.     }  
  42.     public static void main(String[] args) throws Exception  
  43.     {  
  44.         n = 10;  
  45.         array = new int [n][n];  
  46.         fill(n);  
  47.         if (n%2 == 1)  
  48.         {//奇数层次,补充中心点  
  49.             array[n/2][n/2] = n*n;  
  50.         }  
  51.         for (int i = 0; i < n; ++i)  
  52.         {  
  53.             for (int j = 0; j < n; ++j)  
  54.             {  
  55.                 System.out.print(array[i][j]);  
  56.                 System.out.print('\t');  
  57.             }  
  58.             System.out.println();  
  59.         }  
  60.     }  

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

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

  1. char* reverseString(char* srcStr)  
  2. {//不申请变量和空间反转字符串  
  3.     if (srcStr == NULL || strlen(srcStr) == 0)  
  4.     {  
  5.         return NULL;  
  6.     }  
  7.     if (strlen(srcStr) == 1)  
  8.         return srcStr;  
  9.     for (int i = 0,j = strlen(srcStr)-1; i < j ; ++i,--j)  
  10.     {  
  11.         //第一种交换方式,可能会溢出  
  12.         //srcStr[i] = srcStr[i] + srcStr[j];  
  13.         //srcStr[j] = srcStr[i] - srcStr[j];  
  14.         //srcStr[i] = srcStr[i] - srcStr[j];  
  15.         //第二种交换方式,可能会溢出  
  16.         srcStr[i] = srcStr[i] ^ srcStr[j];  
  17.         srcStr[j] = srcStr[i] ^ srcStr[j];  
  18.         srcStr[i] = srcStr[i] ^ srcStr[j];  
  19.     }  
  20.     return srcStr;  

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

  1. char* reverseString(char* srcStr)  
  2. {//不申请变量和空间反转字符串  
  3.     if (srcStr == NULL || strlen(srcStr) == 0)  
  4.     {  
  5.         return NULL;  
  6.     }  
  7.     if (strlen(srcStr) == 1)  
  8.         return srcStr;  
  9.     for (int i = 0,j = strlen(srcStr)-1; i <= j ; ++i,--j)  
  10.     {  
  11.         srcStr[len] = srcStr[i];  
  12.         srcStr[i] = srcStr[j];  
  13.         srcStr[j] = srcStr[len];  
  14.     }  
  15.     srcStr[len] = '\0';  
  16.     return srcStr;  

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

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

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

  1. char* IntToString(int num)  
  2. {  
  3.     int count = 0;  
  4.     bool isNegative = false;  
  5.     if (num < 0)  
  6.     {  
  7.         num = -1 * num;  
  8.         isNegative = true;  
  9.         ++count;  
  10.     }  
  11.     int tmp = num;  
  12.     while (tmp != 0)  
  13.     {  
  14.         ++count;  
  15.         tmp /= 10;  
  16.     }  
  17.     char* result = new char[count+1];  
  18.     if (isNegative == true)  
  19.     {  
  20.         result[0] = '-';  
  21.     }  
  22.     int i = count;  
  23.     while (num != 0)  
  24.     {  
  25.         result[--i] = num % 10 + '0';  
  26.         num /= 10;  
  27.     }  
  28.     result[count] = '\0';  
  29.     return result;