排序

归并排序
采用分而治之的策略，时间复杂度为N*log(N),是非常优秀的排序算法。
代码如下：

package com.time.before.test;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.OutputStreamWriter;import java.util.Random;public class MegreSort2 {    public static Comparable[] aux ;    public static void sort(Comparable[] a){        aux = new Comparable[a.length];        sort(a, 0, a.length -1);    }    public static void sort(Comparable[] a, int low, int high){        if(low >= high) return;        int mid = low + (high - low) / 2 ;        sort(a, low, mid);        sort(a, mid + 1, high);        merge(a, low, mid, high);    }    public static void main(String[] args) throws FileNotFoundException{        buildData();        FileReader fr = new FileReader("D:\\data.txt");        BufferedReader br = new BufferedReader(fr);        try {            String line = br.readLine();            String[] datas = line.split(",");            Comparable[] a = new Comparable[datas.length];            for(int i = 0; i < datas.length; i++) a[i] = Integer.parseInt(datas[i]);            long t = System.currentTimeMillis();            MegreSort2.sort(a);            long sortTime = (System.currentTimeMillis() - t);             System.out.println(sortTime);            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\sortData.txt"),"utf-8"));            int i = 0;            while(i < a.length){                bw.write(a[i] + ",");                i +=1;            }            bw.flush();            bw.close();        } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }//      MegreSort2.sort(a);//      MegreSort2.buildData();    }    public static void merge(Comparable[] a, int low, int mid, int high){        int i = low, j = mid + 1;//      System.out.println(i + "\t" + mid + "\t" + high);        for(int k = low; k <= high; k ++) aux[k] = a [k];        for(int k = low; k <= high; k ++){            if(i > mid)                 a[k] = aux[j ++];            else if(j > high)                 a[k] = aux[i ++];            else if(less(aux[j], aux[i]))                 a[k] = aux[j ++];            else                 a[k] = aux[i ++];        }    }    public static boolean less(Comparable v, Comparable w){        return v.compareTo(w) < 0;    }    public static void buildData() throws FileNotFoundException{        try{//          FileWriter writer = new FileWriter("D:\\data.txt", true);            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\data.txt"),"utf-8"));//          FileOutputStream fos = new FileOutputStream("D:\\data.txt", true);            int i = 0;            Random ra = new Random();//          System.out.println(ra.nextInt(1000000));            while(i <= 100000000){                bw.write(ra.nextInt(100000000) + ",");                i +=1;            }            bw.flush();            bw.close();        }catch(Exception e){        }    }}

写完归并排序后，做了一个小测试，本机内存8G,随机生成1百万个整数，排序时间在1s左右，想进一步测试一亿个整数的排序时间，生成的数据文件大小为847m，出现了java堆溢出问题，设置java参数-Xms和-Xmx时，发现本地内存不够用（原因还未知），只好放弃

快速排序
快排的思想是随机在数组中选一个数，比如数组的第一个值，把该值放到正确的位置，保证该值左边的子数组都小于等于它，右边的子数组的值都大于等它。快排的时间复杂度为O(nlogn)。最换的情况为O(n2)。和归并排序的时间复杂度一样，但是少了新增一个数组内存的开销。
代码如下：

package com.time.before.test;public class QuickSort {    public static void main(String[] args){        Comparable[] a = {2,1,7,1,6,3,18,21,23,12,190,156,156} ;        quickSort(a, 0, a.length -1);        for(int i = 0; i < a.length; i++){            System.out.println(a[i]);        }    }    private static void quickSort(Comparable[] a, int low, int high) {        if(high <= low) return;        int j = partition(a, low, high);        quickSort(a, low, j - 1);        quickSort(a, j + 1, high);    }    private static int partition(Comparable[] a, int low, int high) {        int i = low, j = high +1;        Comparable v = a[low];        while(true){            while(less(a[++ i], v))                if(i == high)                     break;            while(less(v, a[--j]))                if(j == low)                     break;            if(j <= i)                 break;            exch(a, i, j);        }        exch(a, low, j);        return j;    }    private static void exch(Comparable[] a, int i, int j) {        Comparable t = null;        t = a[i];        a[i] = a[j];        a[j] = t;    }    public static boolean less(Comparable v, Comparable w){        return v.compareTo(w) < 0;    }}