归并排序

归并排序包含两个过程：”归”和”并”。其中，”归”是指将原序列分成半子序列，分别对子序列进行递归排序；”并”是指将排好序的各子序列合并成原序列。归并排序算法是一个典型的递归算法，因此也是概念上最为简单的排序算法。与快速排序算法相比，归并排序算法不依赖于初始序列，并且是一种稳定的排序算法，但需要与原序列一样大小的辅助存储空间。

package keking.sort;

import java.util.Arrays;

/**
 * Title: 归并排序
 * Description: 归并排序包括两个过程：归 和 并
 *              "归"是指将原序列分成半子序列，分别对子序列进行递归排序 
 *              "并"是指将排好序的各子序列合并成原序列
 *              归并排序的主要问题是：需要一个与原待排序数组一样大的辅助数组空间
 *              归并排序不依赖于原始序列，因此其最好情形、平均情形和最差情形时间复杂度都一样 
 *              时间复杂度：最好情形O(n)，平均情形O(n^2)，最差情形O(n^2)
 *              空间复杂度：O(n) 
 *              稳 定 性：稳定 
 *              内部排序(在排序过程中数据元素完全在内存)
 * @author keking
 *
 */
public class MergeSort {

    private static void merge(int[] target, 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(target[i] < target[j]){
                temp[k++] = target[i++];
            }else{
                temp[k++] = target[j++];
            }
        }
        while(i <= mid){
            temp[k++] = target[i++];
        }
        while(j <= high){
            temp[k++] = target[j++];
        }
        for(int k1 = 0; k1 < temp.length; k1++){
            target[k1+low] = temp[k1];
        }
    }

    public static void mergeSort(int[] target, int low, int high){
        if(low < high){
            int mid = (low + high) / 2;
            mergeSort(target, low, mid);
            mergeSort(target, mid + 1, high);
            merge(target, low, mid, high);
        }
    }

    public static void main(String[] args) {
        int[] arr = {12,56,564,564,22,34,12,748,65,385,486,53,2,35,64,};
        System.out.println(Arrays.toString(arr));
        mergeSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

运行结果:

[12, 56, 564, 564, 22, 34, 12, 748, 65, 385, 486, 53, 2, 35, 64]
[2, 12, 12, 22, 34, 35, 53, 56, 64, 65, 385, 486, 564, 564, 748]