排序算法原理及实现

插入排序

    public static void insertSort(Comparable[] array)
    {
        int j = 0;
        
        for (int i = 1; i < array.length; i++) {
            Comparable temp = array[i];
            
            for (j = i; j > 0 && (temp.compareTo(array[j - 1]) < 0); j--) {
                array[j] = array[j - 1];
            }
            array[j] = temp;
        }
    }

 

 

归并排序

    public static void mergeSort(Comparable[] array)
    {
        Comparable[] copy = new Comparable[array.length];
        mergeSort(array, copy, 0, array.length - 1);
    }
    
    
    private static void mergeSort(Comparable[] array, Comparable[] temp, int left, int right)
    {
        if (left < right) {
            int middle = (left + right) >> 1;
            mergeSort(array, temp, left, middle);
            mergeSort(array, temp, middle + 1, right);
            merge(array, temp, left, middle + 1, right);
        }
    }
    
    
    private static void merge(Comparable[] array, Comparable[] temp, int left, int right, int rightEnd)
    {
        int leftEnd = right - 1;
        int tempIdx = left;
        int length  = rightEnd - left + 1;
        
        while (left <= leftEnd && right <= rightEnd) {
            if (array[left].compareTo(array[right]) < 0) {
                temp[tempIdx++] = array[left++];
            }
            else {
                temp[tempIdx++] = array[right++];
            }
        }
        
        while (left <= leftEnd) {
            temp[tempIdx++] = array[left++];
        }
        
        while (right <= rightEnd) {
            temp[tempIdx++] = array[right++];
        }
        
        for (int i = 0; i <length; i++, rightEnd--) {
            array[rightEnd] = temp[rightEnd];
        }
    }

快速排序

    public static void quickSort(Comparable[] array)
    {
        quickSort(array, 0, array.length - 1);
    }
    
    
    private static void quickSort(Comparable[] array, int left, int right)
    {
        if (left + 3 <= right) {
            Comparable middle = just(array, left, right);
            
            int i = left, j = right - 1;
            
            for (;;) {
                while (array[++i].compareTo(middle) < 0) {}
                while (array[--j].compareTo(middle) > 0) {System.out.println(j);}
                if (i < j) swap(array, i, j); else break;
            }
            
            swap(array, i, right - 1);
            quickSort(array, left, i);
            quickSort(array, i + 1, right);
        }
        else {
            insertSort(array);
        }
    }
    
    
    private static Comparable just(Comparable[] array, int left, int right)
    {
        int middle = (left + right) >> 1;
                
        if (array[left].compareTo(array[middle]) > 0)  swap(array, left, middle);
        if (array[middle].compareTo(array[right]) > 0) swap(array, middle, right);
        if (array[right].compareTo(array[left]) > 0)   swap(array, left, right);
        
        swap(array, middle, right);
        return array[right];
    }
    
    
    private static void swap(Comparable[] array, int i, int j)
    {
        Comparable tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

先放上代码，原理及注释随后补全