常见排序算法整理（三）----归并排序、快速排序

这几天趁着放假有时间，把几种常见的排序算法整理下，本次整理主要是根据http://blog.csdn.net/u012501459/article/details/44594719所写排序算法为基础，加上自己的一些理解，整理所得，下面继续介绍两种排序算法，归并排序、快速排序。

归并排序

归并排序本质就是两个有序数组合成一个有序数组所用的排序方法，下面是代码，详细内容代码注释有讲解

public class MergeSort {


    public static void main(String[] args) {

        int[] data = {2,5,9,6,3,4,7,1,5,13,8,6};//原始数据

        divMerge(data);//归并排序

        for(int i = 0;i<data.length;i++) {//打印数据
            System.out.print(data[i]+" ");          
        }

    }

    /**
     * 该方法用于将数组分为两个部分
     */
    public static void divMerge(int[] data) {
        if (data.length>1) {//数组长度大于1，说明可以继续分离
            int[] firstArr = new int[data.length/2];//第一个数组
            int[] secondArr = new int[data.length-data.length/2];//第二个数组

            //将元素插入第一个数组
            for(int i = 0 ;i<firstArr.length;i++) {
                firstArr[i] = data[i];
            }
            //将元素插入第二个数组
            for(int m = 0, j = data.length/2;m<secondArr.length;j++,m++) {
                secondArr[m] = data[j];
            }

            divMerge(firstArr);//递归操作
            divMerge(secondArr);

            //将排序完成的数组插入原来的数组
            for(int i = 0;i<firstArr.length;i++) {
                data[i] = firstArr[i];
            }
            //同上
            for(int m = 0, j = data.length/2;m<secondArr.length;j++,m++) {
                data[j] = secondArr[m];
            }
            mergeSort(data);//归并排序      
        }
    }

    /**
     * 归并排序，本质是两个有序数组合并为一个有序数组
     * 合并时，分别从第一个元素开始比较，将小的数取出来
     * 放入新的数组，当一个数组取完后，由于是有序数组，
     * 就把剩下的元素依次放入新数组尾部
     *
     * 在实际过程中可以把一个无序数组从中间分为两个数组，
     * 进行归并排序，但是由于数组是无序的，所以在之前再分别
     * 进行递归操作，把前半部分和后半部分分别进行归并排序，
     * 直至数组长度为1，最后数组就会变为有序
     */
    public static void mergeSort(int[] data ) {

        int mid = data.length/2; 
        int k = 0;//新数组下标
        int first;
        int second;
        int[] tempArr = new int[data.length];  

        //该循环用于分别将两个数组的值进行比较，取出小的数放入新数组
        for (first = 0,second = mid; first < mid && second<data.length ; ) {
            //如果第一个数组中的数小于第二个数组中的数
            //将第一个数组的数放入新数组，反之亦然
            if (data[first]<data[second]) {
                tempArr[k] = data[first];
                k++;
                first++;
            }else {
                tempArr[k] = data[second];
                k++;
                second++;
            }
        }

        //此处用于将元素没有取完的数组插入新数组尾部
        if (first>=mid) {//如果前面数组的下标大于中间值，则说明前面个数组的元素已取完
            while (k<data.length) {
                tempArr[k] = data[second];
                k++;
                second++;
            }
        }else {
            while (k<data.length) {
                tempArr[k] = data[first];
                k++;
                first++;
            }
        }

        //将新数组中的元素插回原数组，此时元素已经有序
        for(int i = 0;i<data.length;i++) {
            data[i] = tempArr[i];
        }       
    }
}

结果：

快速排序

快速排序原理是从无序数组中取出一个key值，将数组中小于key值的放在key值前面，大于key值的放在key值后面，下面是代码，详细说明看注释：

public class QuickSort {


    public static void main(String[] args) {
        int[] data = {5,2,9,6,3,4,7,1,5}; //测试数据

        quickSort(data, 0, data.length-1);//快速排序

        for(int h = 0;h<data.length;h++) {//打印数组
            System.out.print(data[h]+" ");          
        }
    }


    /**
     * 快速排序原理是在一个无序数组中设定一个key值，遍历数组，
     * 将比key值大的元素放在右边，小的放在左边，再分别对左右
     * 两边进行快速排序，直至数组长度为1
     * 
     */
    public static void quickSort(int[] data,int first,int last) {

        //因为需要进行递归，所以需要判断是否长度为1
        //当前下标大于或等于后下标时，可以认为数组长度小于或等于1
        if (first >= last) {
            return;
        }
        int key = data[first];//保存key值
        int i = first;//前下标，数组最小下标开始递增
        int j = last;//后下标，数组最大下标开始递减
        int keyIndex = first;   

        while (i<j) {//前下标必须小于后下标
            //该循环用于找到后面小于key值的元素
            //大于key值的就跳过，后下标自减
            while (i<j&&data[j]>key) {
                j--;
            }

            //key值大于等于找出来的值时，将数组中key值的位置和找出来的值交换
            //注意：是数组中key值的位置交换，不是key值改变，交换后小于key值
            //的元素被放到key值左边
            if (key>=data[j]) {
                data[keyIndex] = data[j];
                data[j] = key;
                keyIndex = j;
                j--;
            }

            //与上面一样，只不过此处是将前面的大于key值的元素与key值交换
            while (i<j&&data[i]<key) {
                i++;
            }
            if (key<=data[i]) {
                data[keyIndex] = data[i];
                data[i] = key;
                keyIndex = i;
                i++;
            }

            //此处是为了数组元素个数为奇数的情况
            //当为奇数时，会出现最后i=j时，key值所在数组位置小于或大于i
            //但是无法进行比较的情况，示例如下：
            //{2,4,3,5（key值位置）,3（i=j的位置）,8,6,7,10}
            //此时5和3无法比较，而出现错误
            //所以需要加入判断，手动进行比较
            if (i == j&&keyIndex!=i) {
                if (keyIndex<i&&data[keyIndex]>data[i]) {
                    data[keyIndex] = data[i];
                    data[i] = key;
                    keyIndex = i;
                }
                if (keyIndex>i&&data[keyIndex]<data[i]) {
                    data[keyIndex] = data[i];
                    data[i] = key;
                    keyIndex = i;
                }
            }
        }
        quickSort(data, first, keyIndex-1);//递归操作，key值的位置不必加入递归
        quickSort(data, keyIndex+1, last);//因为在key值前面的都小于或等于key值，后面的也一样 
    }   
}

运行结果如下：