排序算法(不断更新...)

// SortAlgorithm.java
abstract class SortAlgorithm {
    public abstract void sort(int[] a);
    protected void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

// BubbleSortAlgorithm.java
/**
 * 冒泡排序
 */
public class BubbleSortAlgorithm extends SortAlgorithm {
    public void sort(int[] a) {
        for (int i = a.length - 1; i >= 0; i--) {
            wrapped = false;
            for (int j = 0; j < i; j++) {
                if (a[j] > a[j + 1]) {
                    swap(a, j, j + 1);
                    wrapped = true;
                }
            }
            if (!wrapped) return;
        }
    }
    private boolean wrapped;
}

// InsertionSortAlgorithm.java
/**
 * 插入排序
 */
public class InsertionSortAlgorithm extends SortAlgorithm {
    public void sort(int[] a) {
        for (int j = 1; j < a.length; j++) {
            int t = a[j];
            int i = j - 1;
            while (i >= 0 && a[i] > t) {
                swap(a, i, i + 1);
                i--;
            }
            a[i + 1] = t;
        }
    }
}

// MergeSortAlgorithm.java
/**
 * 归并排序
 */
public class MergeSortAlgorithm extends SortAlgorithm {
    public void sort(int[] a) {
        mergeSort(a, 0, a.length - 1);
    }

    private void mergeSort(int[] a, int p, int r) {
        int q;
        if (p < r) {
            q = (p + r) / 2;
            mergeSort(a, p, q);
            mergeSort(a, q + 1, r);
            merge(a, p, q, r);
        }
    }

    private void merge(int[] a, int p, int q, int r) {
        int n1 = q - p + 1;
        int n2 = r - q;

        int[] left = new int[n1 + 1];
        int[] right = new int[n2 + 1];

        for (int i = 0; i < left.length - 1; i++)
            left[i] = a[p + i];

        for (int i = 0; i < right.length - 1; i++)
            right[i] = a[q + 1 + i];

        left[left.length - 1] = Integer.MAX_VALUE;
        right[right.length - 1] = Integer.MAX_VALUE;

        for (int i = 0, j = 0, k = p; k <= r; k++) {
            if (left[i] < right[j])
                a[k] = left[i++];
            else
                a[k] = right[j++];
        }
    }
}

// QuickSortAlgorithm.java
/**
 * 快速排序
 */
public class QuickSortAlgorithm extends SortAlgorithm {
    public void sort(int[] a) {
        quickSort(a, 0, a.length - 1);
    }

    private int partition(int[] a, int p, int r) {
        int t = a[r];
        int i = p - 1;
        for (int j = p; j < r; j++) {
            if (a[j] <= t) {
                i++;
                swap(a, i, j);
            }
        }
        swap(a, i + 1, r);
        return i + 1;
    }

    private void quickSort(int[] a, int p, int r) {
        if (p < r) {
            int q = partition(a, p, r);
            quickSort(a, p, q - 1);
            quickSort(a, q + 1, r);
        }
    }
}