排序算法总结

1、归并排序

//入口
    public static void mergeSort(int[] array){
        mergeSort(array, 0, array.length-1);
    }

//递归
    private static void mergeSort(int[] array, int low, int high) {
        if(low == high){
        }else {
            int p = low + (high - low)/2;
            mergeSort(array, low, p);
            mergeSort(array, p+1, high);
            mergeTwoData(array, low, high);
        }
    }

//合并两个子数组
    private static void mergeTwoData(int[] array, int low, int high) {
        int[] arrCopy = new int[high-low+1];
        int i,j,mid;
        mid = low + (high - low)/2;
        i = low;
        j = mid+1;
        int t=0;
        while (i<=mid && j<=high){
            if(array[i] <= array[j]){   //将两个数组中较小的先复制到arrCopy中
                arrCopy[t++] = array[i++]; 
            }else {
                arrCopy[t++] = array[j++];
            }
        }
        while (i<=mid){      //若第一个有剩余，将第一个数组剩余的复制到arrCopy中
            arrCopy[t++] = array[i++];
        }
        while (j<=high){      //若第二个有剩余，将第二个数组剩余的复制到arrCopy中
            arrCopy[t++] = array[j++];
        }
        t=0;
        while (low<=high){     //将array对应位置替换成arrCopy
            array[low++] = arrCopy[t++];
        }
    }

2、快速排序

//入口    
    public static void fastSort(int[] array){
        fastSort(array, 0, array.length-1);
    }

//递归调用
    private static void fastSort(int[] array, int low, int high) {
        if(low<high){
            int pos = oneFastSort(array, low, high);
            fastSort(array, low, pos);
            fastSort(array, pos+1, high);
        }
    }

//以key作为中间值，使得key左边的比key小，key右边的比key大
    private static int oneFastSort(int[] array, int low, int high) {
        int key = array[low];
        int flag = 0;
        while (low < high){
            if(flag == 0){
                if(array[high] < key){
                    array[low] = array[high];
                    low++;
                    flag=1;
                }else {
                    high--;
                }
            }else {
                if(array[low] > key){
                    array[high] = array[low];
                    high--;
                    flag=0;
                }else {
                    low++;
                }
            }
        }
        array[low] = key;
        return low;
    }