排序算法

1.归并排序  时间复杂度 平均情况与最坏情况为 O(nlog(n))

public class MergeSort {
    //将一个数组中的两个有序区间[p,q]和(q,r]合成为一个有序区间[p,r]
    //没有返回值也可，因为数组传的是引用
    public int[] merge(int a[],int p,int q,int r){
        //新建两个数组分别存放这两个有序区间
        int[] b = new int[q-p+1];
        int[] d = new int[r-q];
        for(int i = p,k = 0;i<q+1;i++,k++){
            b[k] = a[i];
        }
        for(int i = q+1,k = 0;i<r+1;i++,k++){
            d[k] = a[i];
        }
        int i =0, j =0;
        while(i!=b.length&&j!=d.length){
            if(b[i]<d[j]){
                a[p] = b[i];
                i++;
            }else{
                a[p] = d[j];
                j++;
            }
            p++;
        }
        //数组中剩余的部分,只用复制左半部分的剩余，因为右半部份已经在目标数组中
        if(i!=b.length){
            for(int l = i;l<b.length;l++,p++){
                a[p] = b[l];
            }
        }
        return a;
    }
    public int[] mergeSortF(int nums[],int a,int b){
        //a==b时，表示只有一个元素，则不用进行排序，此时就是递归的终结条件
        if(a<b){
            mergeSortF(nums,a,(a+b)/2);
            mergeSortF(nums,1+(a+b)/2,b);
            return merge(nums,a,(a+b)/2,b);
        }else
            return null;
    }
    //没有返回值也可，因为数组传的是引用
/*    public void mergeSortF(int nums[],int a,int b){
        if(a<b){
            mergeSortF(nums,a,(a+b)/2);
            mergeSortF(nums,1+(a+b)/2,b);
            merge(nums,a,(a+b)/2,b);
        }
    }*/
    public static void main(String[] args){
        MergeSort m = new MergeSort();
        int[] a = {6,1,2,4,5,0,3};
        int[] b = {2,3,5,7,8,10,15};
        int[] c = m.mergeSortF(a,0,6);
        for(int i =0;i<c.length;i++){
            System.out.print(c[i]+" ");
        }
    }
}

 2.快速排序 时间复杂度 平均情况为 O(nlog(n))，最坏情况为O(n^2),因为所取基准值不一定是中位数，空间复杂度  O(log(n))

public class QuickSort {
    public void quickSort(int[] array, int left, int right) {
        int index = partion(array, left, right);
        if (left < index - 1)
            quickSort(array, left, index - 1);//比较左半部分
        if (index < right)
            quickSort(array, index, right);//比较右半部份
    }
    public int partion (int[] array, int left, int right) {
        //找到一个比较的基准值，这里不一定要是中间的数，可以是任意一个范围内数
        int pivot = array[(left + right) / 2];
        while (left <= right) {
            while (array[left] < pivot) left++;
            while (array[right] > pivot) right--;
            if (left <= right) {
                swap(array, left, right);
                left++;
                right--;
            }
        }
        return left;//left往左是小于(/等于)pivot的，往右是大于(/等于)pivot的
    }
    public void swap (int[] array, int left, int right) {
        int temp = array[left];
        array[left] = array[right];
        array[right] = temp;
    }
    public static void main(String[] args){
        QuickSort m = new QuickSort();
        int[] a = {20,1,20,0,5,8,0};
        int[] b = {2,3,5,7,8,10,15};
        m.quickSort(a,0,6);
        for(int i =0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
    }    
}