排序算法解析-优快云博客

个人博客：http://47.104.241.73:8080

排序算法的稳定性：保证排序前两个相等的数的先后顺序和排序后这两个数的先后顺序是一致的。

插入排序【稳定性排序】

思想：将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数组中。算法适用于少量数组的排序。时间复杂度：O(n^2)。是最稳定的排序算法。

/**  
 * 插入排序 
 *  从第一个元素开始，该元素可以认为已经被排序 
 *  取出下一个元素，在已经排序的元素序列中从后向前扫描  
 *  如果该元素（已排序）大于新元素，将该元素移到下一位置   
 *  重复步骤3，直到找到已排序的元素小于或者等于新元素的位置   
 *  将新元素插入到该位置中   
 *  重复步骤2    
 */
public static int[] insertSort(int[] nums){
    int length = nums.length;
    for(int i = 1; i < length; i++){
        int j;
        int tmp = nums[i];
        for(j = i; j > 0 && tmp < nums[j - 1]; j--){
            nums[j] = nums[j - 1];
        }
        nums[j] = tmp;
    }
    return nums;
}

选择排序【不稳定性排序】

思想：是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。

/**  
 * 选择排序
 * 在未排序序列中找到最小元素，存放到排序序列的起始位置  
 * 再从剩余未排序元素中继续寻找最小元素，然后放到排序序列起始位置。  
 * 以此类推，直到所有元素均排序完毕。  
 */
public static int[] selectSort(int[] nums) {
    int size = nums.length;
    for (int i = 0; i < size; i++) {
        int k = i;
        for(int j = size - 1; j > i; j--){
            if(nums[j] < nums[k]){
                k = j;
            }
        }
        int tmp = nums[i];
        nums[i] = nums[k];
        nums[k] = tmp;
    }
    return nums;
}

冒泡排序【稳定排序算法】

思想：是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

/**  
 *  冒泡法排序   
 *  比较相邻的元素。如果第一个比第二个小，就交换他们两个。 
 *  对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最小的数。   
 *  针对所有的元素重复以上的步骤，除了最后一个。  
 *  持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
 */ 
public static int[] bubbleSort(int[] nums) {
    int size = nums.length;
    for (int i = 1; i < size; i++) {
        for (int j = 0; j < size - i; j++) {
            if (nums[j] < nums[j + 1]) {
                nums[j] = nums[j] ^ nums[j + 1];
                nums[j + 1] = nums[j] ^ nums[j + 1];
                nums[j] = nums[j] ^ nums[j + 1];
            }
        }
    }
    return nums;
}

快速排序【不稳定排序算法】

思想：是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

/**  
 * 快速排序 
 *    
 *  从数列中挑出一个元素，称为“基准”  
 *  重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，  
 *  该基准是它的最后位置。这个称为分割（partition）操作。  
 *  递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。  
 */  
 
public static void quickSort(int[] arr, int start, int end){
    if(start >= end){
        return;
    }
    int i = start;
    int j = end;
    int base = arr[start];
    while(i != j){
        while(arr[j] >= base && j > i)
            j--;
        while(arr[i] <= base && i < j)
            i++;
        if(i < j){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    arr[start] = arr[i];
    arr[i] = base;
    quickSort(arr, start, i - 1);
    quickSort(arr, i + 1, end);
}

归并排序【稳定排序算法】

思想：是利用递归与分治的技术将数据序列划分为越来越小的半子表，再对半子表排序，最后再用递归方法将排好序的半子表合并成越来越大的有序序列。

/**
 * 将数组拆分
 * @param la
 * @param ra
 */
public static int[] mergeSort(int[] arr, int left, int right){
    if(left == right){
        return new int[]{arr[left]};
    }
    int mid = (left + right) / 2;
    int[] la = mergeSort(arr, left, mid);
    int[] ra = mergeSort(arr, mid + 1, right);
    return merge(la, ra);
}

/**
 * 合并两个小的数组
 * @param la
 * @param ra
 */
private static int[] merge(int[] la, int[] ra) {
    int[] result = new int[la.length + ra.length];
    int cl = 0;// 左数组的索引
    int cr = 0;// 右数组的索引
    int rp = 0;// 合并后数组的索引
    while(cl < la.length && cr < ra.length){
        result[rp++] = la[cl] < ra[cr] ? la[cl++] : ra[cr++];
    }

    /**
     * 处理其中一个数组还有元素的情况
     */
    while(cl < la.length){
        result[rp++] = la[cl++];
    }
    while(cr < ra.length){
        result[rp++] = ra[cr++];
    }
    return result;
}