领会一些比较巧妙的算法

昨天看到了一些比较巧妙的算法，觉得挺不错的。

参考：http://blog.csdn.net/csdn_zc/article/details/6776929

1. 素数判断

 作者给出了几种方法。

 方法一：

int isPrime(int n) //函数返回1表示是质数，返回0表示不是质数  
{  
int i;  
for (i = 2; i < n; i++)  
if (n % i == 0)  
return 0;  
return 1;  
}  

这个是最原始的做法：从2开始，检测数n是否能被其之前的任意一个数整除，如果能，说明其不是素数。

 方法二：

int isPrime(int n)  
{  
int i;  
for (i = 2; i*i<n; i++)  
if (n % i == 0)  
return 0;  
return 1;  
}  

对上面算法的优化是缩小搜索范围，将范围有[2,n)缩小到[2, sqrt(n)). 因为对于一个小于n的整数x，如何n不能整除x，则n必然不能整除n/x，反之，相同，所以只需到sqrt(n)即可。

 方法三：

int isPrime(int n)  
{  
int i;  
if (n <= 3) return 1;  
if (n % 2 == 0) return 0;  
for (i = 3; i*i<n; i += 2)  
if (n % i == 0)  
return 0;
return 1;  
}  

这个方法是删除掉偶数。因为我们知道，一个数如果不能被2整除，那么也就不能被4、6、等所有的偶数整除。所以我们可以把循环规则改变成先判断2，如果不能被2整除就从3开始判断所有的奇数。

方法四：

int isPrime(int n)  
{  
int i, step = 4;  
if (n <= 3) return 1;  
if (n % 2 == 0) return 0;  
if (n % 3 == 0) return 0;  
for (i = 5; i*i <n; i += step)  
{  
if (n % i == 0)  
return 0;  
step ^= 6;  
}  
return 1;  
} 

 这个方法比较巧妙：我们可以考虑这个事实：所有大于4的质数，被6除的余数只能是1或者5比如接下来的5,7,11,13,17,19都满足。所以，我们可以特殊化先判断2和3。但后面的问题就出现了，因为并非简单的递增，从5开始 是+2,+4,+2,+4,....这样递增的，这样的话，循环应该怎么写呢？从上面的程序中可以看到，每次循环，让step从2变4，或者从4变2，而 所采用的方法就是：一个 step ^= 6; 完成step在2和4之间转换（这个 ^ 符号是C里的异或运算）

 另外：如果要判断一个范围内，比如100之内的素数，我们可以这样做：从2开始判断，如果这个数不能被前面的素数整除，则这个数是素数。已经得到的素数保存在一个表格中。

void print_prime(int n)
{
    int table[100];
    int i,k,j;
    table[0]=2;
    k=1;
    for(i=3;i<n;i++)
    {
        for(j=0;j<k;j++)
            if(i%table[j]==0)
                break;
        if(j>=k)
            table[k++]=i;
    }
    for(i=0;i<k;i++)
    {
        printf("%3d",table[i]);
        if((i+1)%10==0)
            printf("\n");
    }
    printf("\n");

}

2. 菱形打印

作者使用了坐标的思想，

我们知道，要打印的图案是这种：
   *
  ***
 *****
  ***
   *

 如果将菱形中间的点作为坐标原点的话，可以看到“*”所在的点的左边满足|x|+|y|<=c(c是菱形的边长). 

 所以可以得到下面的代码：

#include <stdio.h>
#define ABS(x) (x<0?-(x):(x))
int main(void)
{
    int i,j;
    int c=2;
    for(i=-c;i<=c;i++)
    {
        for(j=-c;j<=c;j++)
        {
            if(ABS(i)+ABS(j)<=c)
                printf("*");
            else
                printf(" ");
        }
        printf("\n");

    }
    return 0;
}

 其他的类型的形状可以使用同样的思路解决。

3. 魔方矩阵

 参考：http://blog.csdn.net/cmutoo/article/details/6492895

 此处的总结比较全面，大家可以看看

#include<stdio.h>  
#include<math.h>  
#define MAX 30  
  
int a[MAX][MAX];    // 幻方矩阵  
int n,s;    // n:阶数，s:幻方数  
int x,y;  
int i,j,k;  
int total,m;  
int ox,oy;  
  
void main()  
{  
    void odd(int m, int index);  
    void singleEven();  
    void FourXFour();  
    void doubleEven();  
      
    do  
    {  
        printf("Please input n(3<=n[<=17]):\t");    // 屏幕可显示的最大阶数为17  
        scanf("%d",&n);  
        if(n<3) continue;   // 幻方最小阶数  
  
        s=n*(pow(n,2)+1)/2; // 幻方数  
        printf("s=%d\n",s);  
  
        if(n%2==1){  
            // 奇阶幻方  
            ox=oy=0;  
            odd(n,0);   // 从1开始填写n阶幻方  
        }  
        else if(n%4==0)  
        {  
            // 双偶阶幻方  
            doubleEven();  
              
        }  
        else if(n%2==0)  
        {  
            // 单偶阶幻方  
            singleEven();  
              
        }  
        // 输出制作好的n阶幻方  
        for(i=0;i<n;i++)  
        {  
            s=0;  
            for(j=0;j<n;j++)  
                s+=a[i][j],printf("%4d",a[i][j]);  
            printf("\t=%d\n",s);  
        }  
  
        fflush(stdin);  // 清除多余或无效的输入  
    }while(1);  
}  
  
/* 奇数阶幻方 
最经典的填法是罗伯特法(楼梯法)，填写方法是这样： 
把1(或最小的数)放在第一行正中；按以下规律排列剩下的n×n-1个数：  
(1)每一个数放在前一个数的右上一格； 
(2)如果这个数所要放的格已经超出了顶行那么就把它放在底行，仍然要放在右一列； 
(3)如果这个数所要放的格已经超出了最右列那么就把它放在最左列，仍然要放在上一行； 
(4)如果这个数所要放的格已经超出了顶行且超出了最右列，那么就把它放在前一个数的下一行同一列的格内； 
(5)如果这个数所要放的格已经有数填入，处理方法同(4)。 
这种写法总是先向“右上”的方向，象是在爬楼梯。 
 
三阶幻方： 
 
   8   1   6 
   3   5   7 
   4   9   2    */  
  
// 解奇阶幻方的通用模块  
// m 为阶数  
// index 为起始标识  
void odd(int m, int index)  
{  
    x=m/2;  
    y=0;  
    for(i=index+1;i<=index+pow(m,2);i++)  
    {  
        a[oy+y][ox+x]=i;  
        if(i%m==0) y++;  
        else x++,y--;  
        // else x++,y+=2; Hourse法  
        x=(x%m+m)%m;  
        y=(y%m+m)%m;  
    }  
}  
  
/* 单偶阶幻方 
n为偶数，且不能被4整除 (n=6，10，14，18，22……；n=4k+2，k=1，2，3，4，5……) 
以n=10为例。这时，k=2 
(1) 把方阵分为A，B，C，D四个象限，这样每一个象限肯定是奇数阶。 
用楼梯法，依次在A象限，D象限，B象限，C象限按奇数阶幻方的填法填数。 
 
6阶幻方第一步： 
 
   8   1   6 | 26  19  24 
   3   5   7 | 21  23  25 
   4   9   2 | 22  27  20 
------------------------- 
  35  28  33 | 17  10  15 
  30  32  34 | 12  14  16 
  31  36  29 | 13  18  11 
 
(2) 在A象限的中间行、中间格开始，按自左向右的方向，标出k格。 
A象限的其它行则标出最左边的k格。 
将这些格，和C象限相对位置上的数，互换位置。 
 
6阶幻方第二步： 
 
  35*  1   6 | 26  19  24 
   3  32*  7 | 21  23  25 
  31*  9   2 | 22  27  20 
------------------------- 
   8* 28  33 | 17  10  15 
  30   5* 34 | 12  14  16 
   4* 36  29 | 13  18  11 
 
(3) 在B象限任一行的中间格，自右向左，标出k-1列。 
(注：6阶幻方由于k-1=0，所以不用再作B、D象限的数据交换) 
将B象限标出的这些数，和D象限相对位置上的数进行交换，就形成幻方。 
 
6阶幻方： 
 
  35   1   6 | 26  19* 24 
   3  32   7 | 21  23* 25 
  31   9   2 | 22  27* 20 
------------------------- 
   8  28  33 | 17  10* 15 
  30   5  34 | 12  14* 16 
   4  36  29 | 13  18* 11   */  
  
void singleEven()  
{  
    int temp;  
    // 步骤一  
    // A象限  
    ox=oy=0;  
    odd(n/2,pow(n/2,2)*0);  
    // D象限  
    ox=oy=n/2;  
    odd(n/2,pow(n/2,2)*1);  
    // B象限  
    ox=n/2,oy=0;  
    odd(n/2,pow(n/2,2)*2);  
    // C象限  
    ox=0,oy=n/2;  
    odd(n/2,pow(n/2,2)*3);  
    // 对已经按ADBC象限以奇阶方式填充的幻方做处理  
    m=(n-2)/4;  
    for(i=0;i<n/2;i++)  
    {     
        // 步骤二  
        for(j=0;j<m;j++)  
        {  
            k=(i==n/4)?n/4+j:j;  
            temp=a[i][k];  
            a[i][k]=a[i+n/2][k];  
            a[i+n/2][k]=temp;  
  
        }  
        // 步骤三  
        for(j=0;j<m-1;j++)  
        {  
            k=n/2+n/4+j;  
            temp=a[i][k];  
            a[i][k]=a[i+n/2][k];  
            a[i+n/2][k]=temp;  
        }  
    }  
}  
  
/* 双偶阶幻方 
n为偶数，且能被4整除 (n=4，8，12，16，20……；n=4k，k=1，2，3，4，5……) 
互补：如果两个数字的和，等于幻方最大数和最小数的和，即 n*n+1，称为互补。*/  
  
/* 四阶幻方 
将数字从左到右、从上到下按顺序填写： 
 
   1   2   3   4 
   5   6   7   8 
   9  10  11  12 
  13  14  15  16 
 
将对角线上的数字，换成与它互补的数字。 
这里，n×n+1 = 4×4+1 = 17； 
把1换成17-1 = 16； 
把6换成17-6 = 11； 
把11换成17-11 = 6； 
把16换成17-16 = 1； 
…… 
换完后就是一个四阶幻方。 
 
  16*  2   3  13* 
   5  11* 10*  8 
   9   7*  6* 12 
   4* 14  15   1* */  
  
void FourXFour()  
{  
    // 对已填写数字的4阶幻方进行对角线互补替换  
    for(i=0;i<4;i++)  
    {  
        a[oy+i][ox+i]=total-a[oy+i][ox+i];  
        a[oy+i][ox+(4-i-1)]=total-a[oy+i][ox+(4-i-1)];  
    }  
}  
  
/* 对于n=4k阶幻方，我们先把数字按顺序填写。 
 
   1   2   3   4   5   6   7   8 
   9  10  11  12  13  14  15  16 
  17  18  19  20  21  22  23  24 
  25  26  27  28  29  30  31  32 
  33  34  35  36  37  38  39  40 
  41  42  43  44  45  46  47  48 
  49  50  51  52  53  54  55  56 
  57  58  59  60  61  62  63  64 
 
写好后，按4*4把它划分成k*k个方阵。 
因为n是4的倍数，一定能用4*4的小方阵分割。 
 
   1   2   3   4 |  5   6   7   8 
   9  10  11  12 | 13  14  15  16 
  17  18  19  20 | 21  22  23  24 
  25  26  27  28 | 29  30  31  32 
--------------------------------- 
  33  34  35  36 | 37  38  39  40 
  41  42  43  44 | 45  46  47  48 
  49  50  51  52 | 53  54  55  56 
  57  58  59  60 | 61  62  63  64 
 
然后把每个小方阵的对角线上的数字换成互补的数字，就构成幻方。 
 
  64*  2   3  61*| 60*  6   7  57* 
   9  55* 54* 12 | 13  51* 50* 16 
  17  47* 46* 20 | 21  43* 42* 24 
  40* 26  27  37*| 36* 30  31  33* 
--------------------------------- 
  32* 34  35  29*| 28* 38  39  25* 
  41  23* 22* 44 | 45  19* 18* 48 
  49  15* 14* 52 | 53  11* 10* 56  
   8* 58  59   5*|  4* 62  63   1* */  
  
void doubleEven()  
{  
    // 填写数字  
    x=y=0;  
    for(i=1;i<=pow(n,2);i++)  
    {  
        a[y][x]=i;  
        if(i%n==0) x=0,y++;  
        else x++;  
    }  
  
    total=1+pow(n,2);   // 最大数和最小数的和  
  
    // 以 4x4 大小分割幻方  
    m=n/4;  
    x=y=0;  
    ox=oy=0;  
    for(k=1;k<=pow(m,2);k++)  
    {  
        // 对每个 4x4 幻方做对角互补替换  
        FourXFour();  
        if(k%m==0) ox=0,oy+=4;  
        else ox=k%m*4;  // 转移到下一个 4x4 幻方  
    }  
}  

#include<stdio.h>  

在matlab中可以通过magic函数得到魔方阵，比如magic(5)就是5阶魔方阵。看matlab中magic.m代码可以发现，它的实现也是分为三种情况的。

function M = magic(n)
%MAGIC  Magic square.
%   MAGIC(N) is an N-by-N matrix constructed from the integers
%   1 through N^2 with equal row, column, and diagonal sums.
%   Produces valid magic squares for all N > 0 except N = 2.

%   Copyright 1984-2002 The MathWorks, Inc. 
%   $Revision: 5.15 $  $Date: 2002/04/15 03:44:23 $

% Historically, MATLAB's magic was a built-in function.
% This M-file uses a new algorithm to generate the same matrices.

n = floor(real(double(n(1))));

% Odd order.
if mod(n,2) == 1
   [J,I] = meshgrid(1:n);
   A = mod(I+J-(n+3)/2,n);
   B = mod(I+2*J-2,n);
   M = n*A + B + 1;

% Doubly even order.
elseif mod(n,4) == 0
   [J,I] = meshgrid(1:n);
   K = fix(mod(I,4)/2) == fix(mod(J,4)/2);
   M = reshape(1:n*n,n,n)';
   M(K) = n*n+1 - M(K);

% Singly even order.
else
   p = n/2;
   M = magic(p);
   M = [M M+2*p^2; M+3*p^2 M+p^2];
   if n == 2, return, end
   i = (1:p)';
   k = (n-2)/4;
   j = [1:k (n-k+2):n];
   M([i; i+p],j) = M([i+p; i],j);
   i = k+1;
   j = [1 i];
   M([i; i+p],j) = M([i+p; i],j);
end

 4.字符串循环移位

 问题，给你一个字符串，要求循环左移n位

比如对"abcdefg" 循环左移2位，我们要得到"cdefgab"
附加条件，不能使用连续辅助空间（包括动态分配），只能使用若干单个变量（即O(1)空间）
首先，我们知道，反转一个字符串操作（"abcd"变"dcba"），是不需要额外数组辅助的，只要头尾数据交换就可以了
然而，可能你不知道，仅仅使用字符串反转可以实现字符串循环移位：

#include <stdio.h>  
#include <string.h>  
//反转字符串，把st与ed所指向的中间的内容反转（包含st不包含ed）  
void str_rev(char* st, char *ed)  
{  
for (--ed; st < ed; ++st, --ed)  
{  
char c;  
c = *st;
*st = *ed;
*ed = c;  
}  
}  
//用三反转等效左移字符串（st与ed之间，包含st不包含ed的内容）  
char* str_shl(char* st, char* ed, int n)  
{  
str_rev(st, &st[n]);  
str_rev( &st[n], ed);  
str_rev(st, ed);  
return st;  
}  
int main()  
{  
char str[] = "abcdefghijklmnopqrstuvwxyz";  
puts( str_shl(str, str + strlen(str), 6) );  
return 0;  
}  

 参考：http://blog.csdn.net/csdn_zc/article/details/6776853

 其中也介绍了数字循环移位的问题：

 C语言中没有提供循环移位的操作符，但可以通过简洁的方式实现循环移位

设一个操作数x有s位则循环左移n位的操作为：
(x << n) | (x >> (s - n));
同理右移n位位:
(x >> n) | (x << (s - n));
实际编程中可以用宏定义实现循环移位：
#define ROTATE_LEFT(x, s, n) ((x) << (n)) | ((x) >> ((s) - (n)))
#define ROTATE_RIGHT(x, s, n) ((x) >> (n)) | ((x) << ((s) - (n)))

几个对位操作的样例如下：
#define SETBIT(REG,N) REG|=(1<<N) //对REG的N位置1
#define CLRBIT(REG,N) REG&=~(1<<N) //对REG的N位清零

#define INVBIT(REG,N) REG^=(1<<N) //对REG的N位取反