排序算法整理:冒泡排序、堆排序、插入排序、归并操作、快速排序、希尔排序、选择排序

SortUtils.java

package prms.utils.sort;

import java.util.Arrays;

/**
 * @ClassName:     SortUtils
 * @Description:  <p> 排序算法 工具类 </p>
 * @author         edgar
 * @email          【[email protected]】
 * @version        V 1.0  
 * @date           2017-3-28 15:35:12
 */
public class SortUtils {
    
    /**
     * @Title:        SortUtils
     * @Description:    私有化构造 ：类不能实例化
     */
    private SortUtils(){}
    
    public static void main(String[] args) {
        int[] arr = { 2, 5, 3, 1, 4 };
        System.out.println("排序前：" + Arrays.toString(arr));
        
         bubbleSort(arr);
         heapSort(arr);
        insertSort(arr);
        mergeSort(arr);
        quickSort(arr);
        selectionSort(arr);
        shellSort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }
    
    
    /**
     * @Title: bubbleSort
     * @Description: 冒泡排序
     *              依次比较相邻的两个数，将小数放在前面，大数放在后面。
     *              即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。
     *              然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，
     *              直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，
     *              将最大的数放到了最后。在第二趟：仍从第一对数开始比较
     *              （因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），
     *              将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），
     *              第二趟结束，在倒数第二的位置上得到一个新的最大数
     *              （其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。 
     * @param data   
     * @return void 
     */
    public static void bubbleSort(int[] data){
        for (int i = 0; i < data.length - 1; i++) {
            for (int j = 0; j < data.length - 1 - i; j++) {
                if (data[j] > data[j + 1]) {
                    swap(data, j, j + 1);
                }
            }
        }
    }
    
    /**
     * @Title: heapSort
     * @Description: 堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征， 使得在当前无序区中选取最大（或最小）关键字的记录变得简单。 　
     *         （1）用大根堆排序的基本思想 　　 
     *          ① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区 　　 
     *          ②再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个 记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，
     *         且满足R[1..n-1].keys≤R[n].key 　　 ③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。
     *         然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，
     *         由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，
     *         且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。 　 直到无序区只有一个元素为止。 　　
     *         （2）大根堆排序算法的基本操作： 　　
     *          ① 初始化操作：将R[1..n]构造为初始堆； 　　 
     *          ②每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换， 然后将新的无序区调整为堆（亦称重建堆）。
     *          
     * @param data   
     * @return void 
     */
    public static 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 {
        private int size = 0;
        private int[] queue;
        
        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);
            }
        }
        
        @SuppressWarnings("unused")
        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;
            }
        }

    }
    
    /**
     * @Title: insertSort
     * @Description: 插入排序基本思想
     *             将n个元素的数列分为已有序和无序两个部分，如插入排序过程示例下所示： 　　
     *             {{a1}，{a2，a3，a4，…，an}} 　　
     *             {{a1⑴，a2⑴}，{a3⑴，a4⑴ …，an⑴}} 　
     *             {{a1(n-1），a2(n-1) ，…},{an(n-1)}} 　　
     *             每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，
     *             找出插入位置，将该元素插入到有序数列的合适位置中。
     * @param data   
     * @return void 
     */
    public static 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);
            }
        }

    }
    
    /**
     * @Title: mergeSort
     * @Description: 归并操作(merge)，也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。 
     *             如设有数列{6，202，100，301，38，8，1} 　　
     *             初始状态： [6] [202] [100] [301] [38] [8] [1] 比较次数 　　
     *             i=1 [6 202 ] [ 100 301] [ 8 38] [ 1 ]　3 　　
     *             i=2 [ 6 100 202 301 ] [ 1 8 38 ]　4 　　
     *             i=3　[ 1 6 8 38 100 202 301 ] 4 
     * @param data   
     * @return void 
     */
    public static void mergeSort(int[] data) {
        int[] temp = new int[data.length];
        mergeSort(data, temp, 0, data.length - 1);
    }
    private static 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++];
            }
        }
    }

    /**
     * @Title: quickSort
     * @Description:快速排序
     *             一趟快速排序的算法是： 　　
     *             1）设置两个变量i、j，排序开始的时候：i=0，j=N-1;　　
     *             2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]; 　　
     *             3）从j开始向前搜索，即由后开始向前搜索（j=j-1即j--）,找到第一个小于key的值A[j]，A[i]与A[j]交换； 　　
     *             4）从i开始向后搜索，即由前开始向后搜索（i=i+1即i++），找到第一个大于key的A[i]，A[i]与A[j]交换； 　　
     *             5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。
     *             找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。） 
     * @param data   
     * @return void 
     */
    public static void quickSort(int[] data) {
        quickSort(data, 0, data.length - 1);
    }
    private static 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);
        }
    }

    /**
     * @param data
     * @param i
     * @param j
     * @return
     */
    private static 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;
    }

    /**
     * @Title: shellSort
     * @Description: 希尔排序：
     *       先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成（n除以d1）个组。所有距离为d1的倍数的记录放在同一个组中。
     *      先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，
     *      即所有记录放在同一组中进行直接插入排序为止。 
     * 
     * 
     *      属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序 　　 
     *      排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，
     *      组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1， 即所有记录放进一个组中排序为止 　　 
     *      初始：d=5 　　49 38 65 97 76 13 27 49 55 04 　　 
     *      49 13 　　|-------------------| 　　 
     *      38 27     |-------------------| 　　 
     *      65 49 　　|-------------------| 　　 
     *      97 55     |-------------------| 　　 
     *      76 04 　　|-------------------| 　　 
     *      一趟结果 　　13 27 49 55 04 49 38 65 97 76 　　 
     *      d=3 　　 13 27 49  55 04 49 38 65 97 76 　　 
     *      13 55 38 76 |------------|------------|------------| 　　 
     *      27 04 65 |------------|------------| 　　 
     *      49 49 97 |------------|------------| 　　
     *      二趟结果  13 04 49* 38 27 49 55 65 97 76 　　 
     *      d=1 　　13 04 49 38 27 49 55 65 97 76
     *      　　 |----|----|----|----|----|----|----|----|----| 　　 三趟结果 　　
     *      04 13 27 38 49 49 55 65 76 97
     * @param data   
     * @return void 
     */
    public static 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);
    }

    /**
     * @param data
     * @param j
     * @param i
     */
    private static 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);
            }
        }
    }
    
    /**
     * @Title: selectionSort
     * @Description: 选择排序基本思路：
     *              把第一个元素依次和后面的所有元素进行比较。第一次结束后，就会有最小值出现在最前面。依次类推
     * @param data   
     * @return void 
     */
    public static void selectionSort(int[] data) {
        for (int x = 0; x < data.length - 1; x++) {
            for (int y = x + 1; y < data.length; y++) {
                if (data[y] < data[x]) {
                    swap(data, x, y);
                }
            }
        }
    }
    
    /**
     * @Title: swap
     * @Description: 交换数组中的两个元素
     * @param data
     * @param i
     * @param j   
     * @return void 
     */
    public static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
    
}