归并排序算法

归并排序算法

概论

归并排序是不稳定的排序算法，会更改元素的相对顺序
比如元素序列 5 2 7 7 8
归并排序后 2 5 7 7 8

归并排序建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
先将一个待排序的序列左右分组，然后对最后的不可在分组的序列进行归并操作成一个更大的有序序列。然后和右边的已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；
否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将
另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以
中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

代码实现：
//测试类

package Suanfa;

import java.util.Arrays;

public class quicksortTest {

    public quicksortTest() {
        // TODO Auto-generated constructor stub
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        QuickSort qSort = new QuickSort();
        int[] intTest = new int[25];
        for (int i = 0; i < intTest.length; i++) {
            intTest[i] = (int) (10000 * Math.random());
        }
        qSort.GetSystemTime();
        qSort.mergeSort(intTest, 0, intTest.length - 1);
        qSort.GetSystemTime();
        System.out.println(Arrays.toString(intTest));
    }

}

//算法实现

package Suanfa;

import java.util.Calendar;

public class QuickSort {

    public QuickSort() {
        // TODO Auto-generated constructor stub
    }

    // 获得当前系统时间
    public void GetSystemTime() {
        Calendar cal = Calendar.getInstance();
        System.out.println(cal.getTime());
    }
    //快速排序
    public void quickSort(int Arrays[], int left, int right) {

        int i, last;

        if (left >= right) /* do nothing if array contains */
            return; /* fewer than two elements */
        // swap(v, left, (left + right) / 2); /* move partition elem */
        last = left; /* to v[0] last指向比left小的数 */
        for (i = left + 1; i <= right; i++) /* partition */
            if (Arrays[i] < Arrays[left])
                swap(Arrays, ++last, i);
        if (left != last)
            swap(Arrays, left, last); /* restore partition elem */
        quickSort(Arrays, left, last - 1);
        quickSort(Arrays, last + 1, right);
    }

    /* swap: interchange v[i] and v[j] */
    void swap(int v[], int i, int j) {
        int temp;
        temp = v[i];
        v[i] = v[j];
        v[j] = temp;
    }

    /**
     * 归并排序
     * @param nums
     * @param low
     * @param high
     *            数组下标的上限
     * @return
     */
    public int[] mergeSort(int[] nums, int low, int high) {
        int mid = (high - low) / 2 + low;
        if (low < high) {
            // 左边
            mergeSort(nums, low, mid);
            // 右边
            mergeSort(nums, mid + 1, high);
            // 左右归并
            merge(nums, low, mid, high);
        }
        return nums;
    }

    /**
     * 归并操作
     * 
     * @param nums
     * @param low
     * @param mid
     * @param high
     */
    private void merge(int[] nums, int low, int mid, int high) {
        // 新的带缓存的数组
        int[] temp = new int[high - low + 1];
        int i = low;// 左指针
        int j = mid + 1;// 右指针
        int k = 0;

        // 把较小的数先移到新数组中
        while (i <= mid && j <= high) {
            if (nums[i] < nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }

        // 把左边剩余的数移入数组
        while (i <= mid) {
            temp[k++] = nums[i++];
        }

        // 把右边边剩余的数移入数组
        while (j <= high) {
            temp[k++] = nums[j++];
        }

        // 把新数组中的数覆盖nums数组
        for (int k2 = 0; k2 < temp.length; k2++) {
            nums[k2 + low] = temp[k2];
        }
    }

}