实习准备——Code

import java.util.Date;
import java.util.GregorianCalendar
/*
 *转换时间
 *Input：25-Oct-2013 14:00:00
 *Output：秒数
 *按我的理解，Calendar和Date有如下区别
 *Calendar是一个日历，会有年月日星期等等一些日历中的概念
 *Date是一个含有日期表示的时间。具体是指时间点
 *
*/
public static int calendarToSecond(String timeStr){
    String time[]=timeStr.split(" ");
    
    String dmy[]=time[0].split("-");
    int day=Integer.parseInt(dmy[0]);
    int month=0;
    //Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec
    if(dmy[1].equals("Jan"))month=1;    
    if(dmy[1].equals("Feb")) month=2;
    if(dmy[1].equals("Mar")) month=3;
    if(dmy[1].equals("Apr")) month=4;
    if(dmy[1].equals("May")) month=5;
    if(dmy[1].equals("Jun")) month=6;
    if(dmy[1].equals("Jul")) month=7;
    if(dmy[1].equals("Aug")) month=8;
    if(dmy[1].equals("Sep")) month=9;
    if(dmy[1].equals("Oct")) month=10;
    if(dmy[1].equals("Nov")) month=11;
    if(dmy[1].equals("Dec")) month=12;    
    int year=Integer.parseInt(dmy[2]);
    
    String hms[]=time[1].split(":");
    int hour=Integer.parseInt(hms[0]);
    int minute=Integer.parseInt(hms[1]);
    int second=Integer.parseInt(hms[2]);
    
    Calendar calendar=new GregorianCalendar(year,month-1,day,hour,minute,second);
    Date date=calendar.getTime();
    String dateStr=String.format("%ts",date);
    int seconds=Integer.parseInt(dateStr);
    
    return seoncds;
}
import java.io.File
import java.io.FileWriter
/*
*存储矩阵
*Input：矩阵
*Output：矩阵文件
*/
public static void saveMatrx(int [][]matrix,int num,String filepath){
    File file=new File(filepath);
    try{
        Writer out=null;
        out=new FileWriter(file);
        StringBuffer buf=new StringBuffer();
        for(int i=0;i<num;i++){
            for(int j=0;j<num;j++){
                buf.append(matrx[i][j]+" ");            
            }
            buf.append("
");
        }
        out.write(buf);
        out.close();
    }catch(Exception e){
        e.printStack();
    }
}
/*
*二分查找
*Input：要查找的数
*Output：在数组中的位置
*Note：要求数组是有序的，如正序
*时间复杂度：最差O(n)，最好O(1),平均O(log2n)
*空间复杂度：无
*/
public static int binarySearch(int data[],int n,int value){
    int start=1;
    int end=n;
    int middle=0;
    while(start<=end){
        middle=(start+end)/2;
        if(value>data[middle]){
            start=middle+1;
        }else if(value<data[middle]){
            end=middle-1;
        }else{
            return middle;
        }
    }
    return 0;//如果没有找到，则返回0，这一点容易忘记！
}
/*
*插入排序之直接插入排序
*Input：乱序数组
*Output：正序数组
*基本思想：前面第一个元素作为有序区，后面的元素不断插入有序区，直到有序区扩展为整个数组
*时间复杂度：
       最好：每个元素只需和前面的元素比较一次，所以总的比较次数n-1次，总的移动次数2(n-1),复杂度O(n)
       最差：第i个元素需要和前面的i-1个元素+哨兵进行比较，第i个元素比较i次，从第2个元素一直到第n个元素需要被放入到有序区，每做一次比较就需要移动一次记录，复杂度为O(n^2)
       平均：第i个元素需要和前面的i-1个元素的一般进行比较，计算类似最差情况，故为O(n^2)
*空间复杂度：O(1)，哨兵的位置
*适用情况：数组已基本有序或者数组元素不多的情况
*稳定排序
*/
public static void directInsertSort(int data[],int n){
    for(int i=2;i<=n;i++){
        data[0]=data[i];//设置哨兵
        for(int j=i-1;data[0]<data[j],j--){
            if(data[0]<data[j]){
               data[j+1]=data[j];
            }
        }
        data[j+1]=data[0];
    }
}
/*
*交换排序之冒泡排序
*Input：乱序数组
*Output：正序数组
*基本思想：数组的后边为有序区，前面为无序区，每冒一次泡，
*都是无序区的元素两两比较，若第一个元素大于第二个元素，则两个元素进行交换，直到无序区的最大的元素被放到有序区
*时间复杂度：
*      最好：正序，不用进行移动，比较次数是n-1次，故为O(n)
*      最差：逆序，会进行n-1次遍历，第i次遍历，需要比较n-i次，i是从1到n-1的，移动次数是3倍的比较次数，故为O(n^2)
*      平均：时间复杂度与最坏情况同数量级，为O(n^2)
*空间复杂度：O(1)，用于交换元素
*稳定排序
*/
public static void bubbleSort(int data[],int n){
    int exchange=n;//用来标记某一次遍历是否进行了元素的交换，所以，exchange要实时记录交换元素的位置
    int bound=exchange;//用来标记每一次遍历的范围
    while(exchange){
        bound=exchange;
        exchange=0;
        for(int i=1;i<bound;i++){
            if(data[i]>data[i+1]){
                data[0]=data[i];
                data[i]=data[i+1];
                data[i+1]=data[0];
                exchange=i;
            }   
        }
    }
}
/*
*交换排序之快速排序
*Input：乱序数组
*Output：正序数组
*基本思想：每次选定一个轴值，通过比较和移动，为轴值确定最后的位置，使得左边的元素均小于轴值，右边的元素均大于轴值
*时间复杂度：
       最好：轴值总是能把元素平均分成两部分。每次划分，假设需要划分的元素个数为i个，则该次划分需要遍历i次，总共需要log2n次划分，故为O(nlog2n);
       最差：轴值总是待划分序列中最小的或者最大的，因此，每次划分只得到一个比上次少一个元素的子序列，另一个子序列为空，故为O(n^2);
       平均：O(nlog2n)
*空间复杂度：该算法是递归的，则取决于递归的深度
       最好：O(log2n)
       最差：要进行n-1次递归调用，故为O(n)
       平均：O(log2n)
*适用情况：元素个数较多且记录随机排列
*不稳定排序
*快排的平均性能是迄今为止内排序中最好的。快排应用广泛，典型的是UNIX系统调用库函数例程中的qsort函数
*/
public static void quickSort(int data[],int start,int end){
    if(start<end){
        pivot=partition(data,start,end);//一次 划分得到轴值，函数为partition
        quickSort(data,start,pivot-1);//递归的对左侧子序列进行快排
        quickSort(data,pivot+1,end);//递归的对右侧子序列进行快排
    }
}
//划分时是从右侧开始扫描，也就是先j--，再i++
public static int partition(int data[],int start,int end){//没必要每次都把元素总的个数传递进来
    int i=start;
    int j=end;
    while(i<j){//i=j时划分停止
        while(i<j&&data[i]<=data[j]){//当两个元素相等时，继续遍历，无需交换
            j--;
        }
        if(i<j){
            temp=data[i];
            data[i]=data[j];
            data[j]=temp;
            i++;
        }
        while(i<j&&data[i]<=data[j]){
            i++;
        }
        if(i<j){
            temp=data[i];
            data[i]=data[j];
            data[j]=temp;
            j--;
        }
    }
    return i;//i为轴值的最终位置
}