滕飞

  算法的优化
经过一周的课程设计，对算法又有了一点新的认识，好的算法可以提高程序的运行效率，减少时间和空间复杂度。
  比如数组的移位问题，如果有一个长度为1000的数组，如果想将其左移100位。按正常的算法，数组只能先向左移动一位，然后重复一百次
这样的操作。因为数组只能借助中间变量来保存一个数组元素，然后依次向作移动
  其代码形式如下：
  class test1{
     static int a[] = new int[1000];
     static int number = 0;
     public static void set(){
           for(int k=0;k<1000;k++,number++){
                 a[k] = number;
           }
     }
     
     public static void main(String args[]){
           set();
           int middle;
           print();

           for(int i=0;i<100;i++){
                 middle = a[0];
                 for(int j=1;j<1000;j++){
                       a[j-1]=a[j];
                 }
                 a[999] = middle;
           }
           print();
     }
     public static void print(){
           for(int i=0;i<1000;i++){
                 System.out.print(a+" ");
           }
           System.out.println();
     }
  }
  其中算法的核心部分，亦即
           for(int i=0;i<100;i++){
                 middle = a[0];
                 for(int j=1;j<1000;j++){
                       a[j-1]=a[j];
                 }
                 a[999] = middle;
           }
  的时间复杂度是O(n*n),而如果采用下面的方法，时间复杂度会大大降低。
  第一步：将数组前100个元素逆置。这样原数组就变成了a[99]~a[0]，a[100]~a[999]。
  第二步：将数组后900个元素逆置。原数组变成a[99]~a[0],a[999]~a[100]。
  第三步：将整个数组全部逆置。数组就变成了a[100]~a[999],a[0]~a[99]的形式。即移位完成。
  其代码形式如下：
  class Converse{
           void L_Converse(int a[],int 1000,int 100){
                 Reverse(a,0,100);
                 Reverse(a,100,1000);
                 Reverse(a,0,1000);
           }
           private void Reverse(int a[],int from,int to){
                 int middle;
                 for(int i=0;i<(to-from+1)/2;i++){
                       middle=a[from+i];
                       a[from+i]=a[to-i-1];
                       a[to-i-1]=middle;
                 }
           }
  }
  可以用上面的代码替换第一种代码的核心部分，这样时间复杂为O(3*n)，也就是O(n)，这样时间复杂度大大降低。所以好的算法可以大大提高程序的性能。
  可以试想一个10000个元素甚至更多个元素的数组，若其中的元素也不是整形的，那么算法优化的意义就更大了。