1. 字符串逆序,最简单的方法,就是反过来读。

  1. // 字符串逆序  
  2. char* Reverse(char* p)  
  3. {  
  4.     char* t=p;  
  5.     while(*t++)  
  6.         ;  
  7.     t-=2;  
  8.     //char* s = new char[sizeof(char)*(t-p+2)];  
  9.     char* s=(char*) malloc(sizeof(char)*(t-p+2));  
  10.     char* r=s;  
  11.     while(t>=p)  
  12.     {  
  13.         *s++=*t--;  
  14.     }  
  15.     *s='\0';  
  16.     return r;  


2. 字符串逆序还有一种方法是,前后交换。

  1. //原地逆序  
  2. char* Reverse_b(char* p)  
  3. {  
  4.     char* t=p;  
  5.     char* r=p;  
  6.     while(*t++)  
  7.         ;  
  8.     t-=2;  
  9.  
  10.     while(t>r)  
  11.     {  
  12.         char c=*r;    
  13.         *r++=*t;  
  14.         *t--=c;  
  15.     }  
  16.  
  17.     return p;  


3. 快速排序是冒泡排序的改进,取一个参考值,经过一遍遍历,大于这个参考值的数在右边,小于参考值的数在左边。

 

  1. //快速排序  
  2. int* QuickSort(int* p,int l, int r)  
  3. {  
  4.     int m=p[l];  
  5.     int n=l;  
  6.     int t;  
  7.     int i=l;  
  8.     int j=r;  
  9.  
  10.     if(r>l)  
  11.     {  
  12.         while(j>i)  
  13.         {  
  14.             while (m<=p[j]&&j>i) j--;  
  15.             if(j>i)  
  16.             {  
  17.                 p[n]=p[j];  
  18.                 p[j]=m;  
  19.                 n=j;  
  20.             }  
  21.  
  22.             while (p[i]<=m&&j>i)i++;  
  23.             if(j>i)  
  24.             {  
  25.                 p[n]=p[i];  
  26.                 p[i]=m;  
  27.                 n=i;  
  28.             }  
  29.         }  
  30.         QuickSort(p,l,n);  
  31.         QuickSort(p,n+1,r);  
  32.     }  
  33.  
  34.     return p;  

 

  1. //求最小公倍数  
  2. // 最小公倍数=两个数相乘/最大公约数  
  3. // 假设b=x%y, 如果一个数能被x,y整除,那么一定可以被b,y 整除,这样一次类推,知道余数为零。  
  4.  
  5. int LCM(int x,int y)  
  6. {  
  7.     int m=x,n=y;  
  8.       
  9.     if(m>0&&n>0)  
  10.     {  
  11.         int bm%n;  
  12.         while(b)  
  13.         {  
  14.             m=n;  
  15.             n=b;  
  16.             b=m%n;  
  17.         }  
  18.  
  19.         return x*y/n;  
  20.     }  
  21.  
  22.     return 0;  
  23. }