用Java来写常见的排序算法

/**
 * 各种排序算法
 *
 * @author huwei
 *
 */
public class Sort {
    public static void main(String[] args) {
        int[] a = { 60, 57, 89, 47, 57, 98, 45, 35, 73 };
        Sort sort = new Sort();
        sort.quickSort(a);
        for (int i = 0; i < a.length; i++) {
            System.out.print(" " + a[i] + " ");
        }
    }
 
    /**
     * 插入排序
     *
     * @param data
     */
    public void insertSort(int[] data) {
        for (int i = 1; i < data.length; i++) {
            for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
                swap(data, j, j - 1);
            }
        }
    }
 
    /**
     * 冒泡排序
     *
     * @param data
     */
    public void bubbleSort(int[] data) {
        for (int i = 0; i < data.length; i++) {
            for (int j = data.length - 1; j > i; j--) {
                if (data[j] < data[j - 1]) {
                    swap(data, j, j - 1);
                }
            }
        }
 
    }
 
    /**
     * 选择排序
     *
     * @param data
     */
    public void selectSort(int[] data) {
        for (int i = 0; i < data.length; i++) {
            int lowIndex = i;
            for (int j = data.length - 1; j > i; j--) {
                if (data[j] < data[lowIndex]) {
                    lowIndex = j;
                }
            }
            swap(data, i, lowIndex);
        }
    }
 
    /**
     * shell排序
     *
     * @param data
     */
    public void shellSort(int[] data) {
        for (int i = data.length / 2; i > 2; i /= 2) {
            for (int j = 0; j < i; j++) {
                insertSort(data, j, i);
            }
        }
        insertSort(data, 0, 1);// 最后进行一次插入排序
    }
 
    private void insertSort(int[] data, int start, int inc) {
        for (int i = start + inc; i < data.length; i += inc) {
            for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
                swap(data, j, j - inc);
            }
        }
    }
 
    /**
     * 快速排序 重点
     *
     * @param data
     */
    public void quickSort(int[] data) {
        quickSort(data, 0, data.length - 1);
    }
 
    private void quickSort(int[] data, int i, int j) {
        int pivotIndex = (i + j) / 2;
        // swap
        swap(data, pivotIndex, j);
 
        int k = partition(data, i - 1, j, data[j]);
        swap(data, k, j);
        if ((k - i) > 1)
            quickSort(data, i, k - 1);
        if ((j - k) > 1)
            quickSort(data, k + 1, j);
 
    }
 
    private int partition(int[] data, int l, int r, int pivot) {
        do {
            while (data[++l] < pivot)
                ;
            while ((r != 0) && data[--r] > pivot)
                ;
            swap(data, l, r);
        } while (l < r);
        swap(data, l, r);
        return l;
    }
 
    /**
     * 归并排序
     *
     * @param data
     */
    public void mergeSort(int[] data) {
        int[] temp = new int[data.length];
        mergeSort(data, temp, 0, data.length - 1);
    }
 
    private void mergeSort(int[] data, int[] temp, int l, int r) {
        int mid = (l + r) / 2;
        if (l == r)
            return;
        mergeSort(data, temp, l, mid);
        mergeSort(data, temp, mid + 1, r);
        for (int i = l; i <= r; i++) {
            temp[i] = data[i];
        }
        int i1 = l;
        int i2 = mid + 1;
        for (int cur = l; cur <= r; cur++) {
            if (i1 == mid + 1)
                data[cur] = temp[i2++];
            else if (i2 > r)
                data[cur] = temp[i1++];
            else if (temp[i1] < temp[i2])
                data[cur] = temp[i1++];
            else
                data[cur] = temp[i2++];
        }
    }
 
    /**
     * 堆排序
     *
     * @param data
     */
    public void heapSort(int[] data) {
        MaxHeap h = new MaxHeap();
        h.init(data);
        for (int i = 0; i < data.length; i++)
            h.remove();
        System.arraycopy(h.queue, 1, data, 0, data.length);
    }
 
    private static class MaxHeap {
        void init(int[] data) {
            this.queue = new int[data.length + 1];
            for (int i = 0; i < data.length; i++) {
                queue[++size] = data[i];
                fixUp(size);
            }
        }
 
        private int size = 0;
 
        private int[] queue;
 
    /*  public int get() {
            return queue[1];
        }*/
 
        public void remove() {
            swap(queue, 1, size--);
            fixDown(1);
        }
 
        // fixdown
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size) {
                if (j < size && queue[j] < queue[j + 1])
                    j++;
                if (queue[k] > queue[j]) // 不用交换
                    break;
                swap(queue, j, k);
                k = j;
            }
        }
 
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j] > queue[k])
                    break;
                swap(queue, j, k);
                k = j;
            }
        }
 
    }
 
    public static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}