package Com.Sort;

/**
* 各種高階排序方法的實現
*
* @author Jane
*/
public class AdvanceSort {

// 列印陣列
public static <T extends Comparable<? super T>> void print(T[] a) {
    for (T t : a) {
        System.out.print(t + " ");
    }
    System.out.println();
}

**// 希爾排序  亞次方的時間界O(N^3/2)**
public static <T extends Comparable<? super T>> void shellSort(T[] a) {
    int j;
    for (int gap = a.length / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < a.length; i++) {
            T tmp = a[i]; // 鎸夌収姣忎竴涓閲忔彃鍏ユ帓搴�
            for (j = i; j >= gap && tmp.compareTo(a[j - gap]) < 0; j -= gap)
                a[j] = a[j - gap];
            a[j] = tmp;
        }
    }
}

**// 歸併排序，O(n)的輔助儲存，O(nlogn)的時間界**
private static <T extends Comparable<? super T>> void mergeSort(T[] a, T[] temp, int left, int right) {
    if (left < right) {
        int center = (left + right) / 2;
        mergeSort(a, temp, left, center);
        mergeSort(a, temp, center + 1, right);
        merge(a, temp, left, center + 1, right);
    }
}

private static <T extends Comparable<? super T>> void merge(T[] a, T[] temp, int leftpos, int rightpos,
        int rightEnd) {
    int leftEnd = rightpos - 1;
    int tmpPos = leftpos;
    int numElements = rightEnd - leftpos + 1;

    while (leftpos <= leftEnd && rightpos <= rightEnd) {
        if (a[leftpos].compareTo(a[rightpos]) <= 0)
            temp[tmpPos++] = a[leftpos++];
        else
            temp[tmpPos++] = a[rightpos++];
    }

    while (leftpos <= leftEnd)
        temp[tmpPos++] = a[leftpos++];

    while (rightpos <= rightEnd)
        temp[tmpPos++] = a[rightpos++];

    for (int i = 0; i < numElements; i++, rightEnd--)
        a[rightEnd] = temp[rightEnd];

}

**// 歸併排序 外部呼叫介面**
public static <T extends Comparable<? super T>> void mergeSort(T[] a) {
    T[] tmp = (T[]) new Comparable[a.length];
    mergeSort(a, tmp, 0, a.length - 1);
}

**// 堆排序 O(nlogn)可以不用輔存**
public static <T extends Comparable<? super T>> void heapSort(T[] a) {
    for (int i = a.length / 2; i >= 0; i--)
        percDown(a, i, a.length);

    for (int i = a.length - 1; i > 0; i--) {
        swapReference(a, 0, i);
        percDown(a, 0, i);
    }
}

// 下慮操作
private static <T extends Comparable<? super T>> void percDown(T[] a, int i, int n) {
    int child;
    T tmp;
    for (tmp = a[i]; 2 * i + 1 < n; i = child) {
        child = 2 * i + 1;
        if (child != n - 1 && a[child].compareTo(a[child + 1]) < 0)
            child++;
        if (tmp.compareTo(a[child]) < 0)
            a[i] = a[child];
        else
            break;
    }
    a[i] = tmp;
}

private static <T extends Comparable<? super T>> void swapReference(T[] a, int i, int n) {
    T tmp = a[n];
    a[n] = a[0];
    a[0] = tmp;
}

**// 快速排序，常見那種選擇第一個作為pivot**
public static <T extends Comparable<? super T>> void quickSort(T[] a, int i, int j) {
    if ((j - i) <= 0)
        return;
    int left = i;
    int right = j;
    T tmp = a[left];
    while (i < j) {
        while (i < j && tmp.compareTo(a[j]) <= 0)
            j--;
        a[i] = a[j];
        while (i < j && tmp.compareTo(a[i]) >= 0)
            i++;
        a[j] = a[i];
    }
    a[i] = tmp;
    quickSort(a, left, i - 1);
    quickSort(a, i + 1, right);
}

**// 快速排序，選擇三個試驗點的中值作為pivot**
public static <T extends Comparable<? super T>> void quickSort2(T[] a, int left, int right) {
    if (right - left >= 4) {
        T pivot = median3(a, left, right);
        int i = left;
        int j = right - 1;
        for (;;) {
            while (a[++i].compareTo(pivot) < 0) {
            }
            while (a[--j].compareTo(pivot) > 0) {
            }
            if (i < j)
                swap(a, i, j);
            else
                break;
        }

        swap(a, i, right - 1);
        quickSort2(a, left, i - 1);
        quickSort2(a, i + 1, right);
    } else
        AdvanceSort.quickSort(a, left, right);
}

private static <T extends Comparable<? super T>> T median3(T[] a, int i, int j) {
    int center = (i + j) / 2;
    if (a[center].compareTo(a[i]) < 0)
        swap(a, center, i);
    if (a[j].compareTo(a[i]) < 0)
        swap(a, j, i);
    if (a[j].compareTo(a[center]) < 0)
        swap(a, j, center);

    swap(a, center, j - 1);
    return a[j - 1];
}

private static <T extends Comparable<? super T>> void swap(T[] a, int i, int j) {
    T tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}
 

}

簡單排序的實現

package Com.Sort;
/**
 * 
 * @author Jane
 */
public class SimpleSort {

    //列印陣列
    public static  <T extends Comparable<? super T>> void print(T [] a)
    {
        for (T t : a) {
            System.out.print(t+" ");
        }
        System.out.println();
    }
    **//插入排序 O(n^2)**
 

    public static <T extends Comparable<? super T>> void insertSort(T [] a)
    {
        int j;
        for(int p=1;p<a.length;p++)
        {
            T tmp=a[p];
            for(j=p;j>0&&tmp.compareTo(a[j-1])<0;j--)
                a[j]=a[j-1];        
            a[j]=tmp;
        }
    }
    **//選擇排序**
 

    public static <T extends Comparable<? super T>> void selectSort(T [] a)
    {
        for(int i=0;i<a.length-1;i++)
        {
            for(int j=i+1;j<a.length;j++)
            {
                if(a[j].compareTo(a[i])<0)
                {
                    T tmp=a[j];
                    a[j]=a[i];
                    a[i]=tmp;
                }
            }
        }
    }
    **//氣泡排序**
    public static <T extends Comparable<? super T>> void maoPaoSort(T [] a)
    {
        boolean flag=true;
        for(int i=a.length;i>0;i--)
        {
            for(int j=0;j<i-1;j++)
            {
                if(a[j+1].compareTo(a[j])<0)
                {
                    T tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                    flag=false;
                }
            }
            if(flag)
                break;
        }
    }
}