排序算法自我练习（四）——归并算法

归并算法

基本概念

分而治之方法

归并排序在极不平衡的集合中的情况，暂时不考虑。考虑平衡风格法：
将n个元素风格为A和B两个集合，A集合中含有n/k个元素， B中包含其余的元素。递归的使用分而治之的方法对A和B进行排序。将A和B合并为一个集合。
k = 2的排序方法称之为二路归并排序方法。
为了消除不必要的递归，改进方法从1开始进行序列合并。

> 初始：[8][4][5][6][2][1][7][3]
> 归并：[4  8][5  6][1  2][3  7]
> 归并：[4 5 6 8]   [1 2 3 7]
> 归并：[1 2 3 4 5 6 7 8] 

代码演示

import java.util.*;

public class MergeSort {
       public void Merge(int[] array, int low, int mid, int high) {

        int i = low; // i是第一段序列的下标
        int j = mid + 1; // j是第二段序列的下标
        int k = 0; // k是临时存放合并序列的下标
        int[] array2 = new int[high - low + 1]; // array2是临时合并序列
        // 扫描第一段和第二段序列，直到有一个扫描结束
        while (i <= mid && j <= high) {
            // 判断第一段和第二段取出的数哪个更小，将其存入合并序列，并继续向下扫描
            if (array[i] <= array[j]) {
                array2[k] = array[i];
                i++;
                k++;
            } else {
                array2[k] = array[j];
                j++;
                k++;
            }
        }
        // 若第一段序列还没扫描完，将其全部复制到合并序列
        while (i <= mid) {
            array2[k] = array[i];
            i++;
            k++;
        }
        // 若第二段序列还没扫描完，将其全部复制到合并序列
        while (j <= high) {
            array2[k] = array[j];
            j++;
            k++;
        }
        // 将合并序列复制到原始序列中
        for (k = 0, i = low; i <= high; i++, k++) {
           array[i] = array2[k];
        }
    }
    public void MergePass(int[] array, int gap, int length) {
        int i = 0;

        // 归并gap长度的两个相邻子表
        for (i = 0; i + 2 * gap - 1 < length; i = i + 2 * gap) {
            Merge(array, i, i + gap - 1, i + 2 * gap - 1);
        }
        // 余下两个子表，后者长度小于gap
        if (i + gap - 1 < length) {
            Merge(array, i, i + gap - 1, length - 1);
        }
    }

    public int[] mergeSort(int[] list, int n) {
        for (int gap = 1; gap < n; gap = 2 * gap) {
            MergePass(list, gap, n);
        }
        return list;
    }
}

算法分析

时间复杂度O(nlog2n)