归并排序思路与泛型版本的实现

Brian — Thu, 12 Jun 2008 16:54:00 GMT

一.归并排序的思路
        ①把 n 个记录看成 n 个长度为 l 的有序子表；
        ②进行两两归并使记录关键字有序，得到 n/2 个长度为 2 的有序子表；
        ③重复第②步直到所有记录归并成一个长度为 n 的有序表为止。
二.归并排序算法实例
        对于归并排序算法这类的分治算法，其核心就是"分解"和"递归求解"。对于"分解"实例，会在下面分析msort()方法中给出。我们先看合并的过程。
        以下面描述的序列为例，在索引范围内[first , last)的序列还有九个整数元素，它由索引范围为[first , mid]的四个元素有序子列表A和索引范围[mid , last]的五个元素有序子列表B组成。

        步骤1：比较arr[indexA]=7与arr[indexB]=12。将较小的元素7复制到数组tempArr的索引indexC处。并将indexA和indexC都指向下一个位置。

        步骤2：比较arr[indexA]=10与arr[indexB]=12。将较小的元素10复制到数组tempArr的索引indexC处。并将indexA和indexC都指向下一个位置。

        步骤3：比较arr[indexA]=19与arr[indexB]=12。将较小的元素12复制到数组tempArr的索引indexC处。并将indexB和indexC都指向下一个位置。

        步骤4-7：依次成对比较两子表的元素将17，19，21，25复制到数组tempArr。此时，indexA到达子表A的未尾(indexA = mid)，indexB引用的值为30。

        步骤8-9：将未到尾部的子表剩余数据复制到tempArr中。

        步骤10：将tempArr复制到原始数据arr中。

三.归并排序算法的实现
    了解了合并过程，那么理解下面的代码并不是一件难事。下面提供了归并算法的非泛型版本和泛型版本。

public class MergeSort {

    public static void sort(Object[] arr) {
        //create a temporary array to store partitioned elements
        Object[] tempArr = arr.clone();

        //call msort with arrays arr and tempArr along
        //with the index range
        msort(arr, tempArr, 0, arr.length);
    }

    public static <T extends Comparable super T>> void sort(T[] arr) {
        //create a temporary aray to store partitioned elements
        T[] tempArr = (T[]) arr.clone();

        //call msort with arrays arr and tempArr along
        //with the index range
        msort(arr, tempArr, 0, arr.length);
    }

    private static void msort(Object[] arr, Object[] tempArr, int first,
                              int last) {
        //if the sublist has more than 1 element continue
        if (first + 1 < last) {
            //for sublists of size 2 or more, call msort()
            //for the left and right sublists and than
            //merge the sorted sublists using merge()
            int midpt = (last + first) / 2;

            msort(arr, tempArr, first, midpt);
            msort(arr, tempArr, midpt, last);

            //if list is already sorted, just copy src to
            //dest; this is an optimization that results in faster
            //sorts for nearly ordered lists
            if (((Comparable) arr[midpt - 1]).compareTo(arr[midpt]) <= 0)
                return;
            //the elements in the ranges [first,mid] and
            //[mid,last] are ordered;merge the ordered sublists
            //into an ordered sequence in the range [first , last]
            //using the temporary array
            int indexA, indexB, indexC;

            //set indexA to scan sublist A with rang [first , mid]
            //and indexB to scan sublist B with rang [mid , last]
            indexA = first;
            indexB = midpt;
            indexC = first;

            //while both sublists are not exhausted, compare
            //arr[indexA] and arr[indexB]; copy the smaller
            //to tempArr
            while (indexA < midpt && indexB < last) {
                if (((Comparable) arr[indexA]).compareTo(arr[indexB]) < 0) {
                    tempArr[indexC] = arr[indexA]; //copyto tempArr
                    indexA++; //increment indexA
                } else {
                    tempArr[indexC] = arr[indexB]; //copyto tempArr
                    indexB++; //increment indexB
                }
                indexC++; //increment indexC
            }
            //copy the tail of the sublist that is not exhausted
            while (indexA < midpt) {
                tempArr[indexC++] = arr[indexA++]; //copy to tempArr
            } while (indexB < last) {
                tempArr[indexC++] = arr[indexB++]; //copy to tempArr
            }
            //copy elements form temporary array to original array
            for (int i = first; i < last; i++)
                arr[i] = tempArr[i];
        }
    }
}

        上述代码中最核心的msort()方法是一递归算法。下图说明了msort()方法中子列表的分割与合并。

四.归并排序算法的效率
        归并排序的最坏情况与平均情况运行时间都为O(nlog₂n)。假定数组具有n=2^k个元素。如下图：

        在层数0上对msort()方法的第一个调用会产生两个递归调用，这两个递归调用产生长度为n/2的两个半部分列表，而merge()方法将上述两个半部分列表组合的一个有序的n元素列表；在层数1上存在两个msort()方法的调用，每个调用又会产生另外两个对长度为n/4的列表的递归调用。每个合并会将两个长度为n/4的子列表连接为一个长度为n/2的有序列表；在层数2上存在对merge()方法的4=2²个调用，每个调用会创建一个长度为n/4的有序列表。通常，在层数i上存在对merge()方法的2ⁱ个调用，每个调用会创建一个长度为n/2ⁱ的有序子列表。
        层数0：存在对merge()方法的1=2⁰次调用。这个调用对n个元素排序。
        层数1：存在对merge()方法的2=2¹次调用。这个调用对n/2个元素排序。
        层数2：存在对merge()方法的4=2²次调用。这个调用对n/4个元素排序。
        ......
        层数i：存在对merge()方法的2ⁱ次调用。这个调用对n/i个元素排序。
        在树中的每一层，合并涉及具有线性运行时间的n/2ⁱ个元素，这个线性运行时间需要少于n/2_i次的比较。在层数i上组合的2ⁱ个合并操作需要少于2ⁱ*n/2ⁱ=n次的比较。假定n=2^k,分割过程会在n/2^k=1的k层数上终止。那么所有层上完成的工作总量为:k*n = nlog₂n。因此msort()方法的最坏情况效率为O(nlog₂n)。

Brian 2008-06-13 00:54 发表评论

插入排序思路与泛型版本的实现

Brian — Wed, 11 Jun 2008 15:56:00 GMT

一.插入排序算法的思路
        假定这个数组的序是排好的，然后从头往后，如果有数比当前外层元素的值大，则将这个数的位置往后挪，直到当前外层元素的值大于或者等于它前面的位置为止。
二.插入排序算法实例
        用五个名字(Monroe,Chin,Flores,Stein和Dare)的列表的插入排序算法为例：
                                       Monroe    从Monroe开始

        处理名字Chin        Chine Monroe    将Chin插入到位置0；Monroe移动至位置1

        处理名字Flores     Chine Flores Monroe    将Flores插入到位置1；Monroe移动至位置2

        处理名字Stein       Chine Flores Monroe Stein    Stein位置正确

        处理名字Dare       Chine Dare Flores Monroe Stein    将Dare插入在位置1；列表尾部向右移动

三.插入排序算法的实现

public class InsertSort {
    //sort an array of elements using insertion sort
    public static <T extends Comparable super T>> void sort(T[] arr) {
        int i, j, n = arr.length;
        T target;

        /** *//**
         * place element at index i into the sublist
         * from index 0 to i-1 where 1<= i,
         * so it is in the correct positon
         */
        for (i = 1; i < n; i++) {
            //index j scans down list from index i looking for
            //correct position to locate target; assigns it to
            //arr at index j
            j = i;
            target = arr[i];
            //locate insertion point by scanning downward as long
            //as target < arr[j] and we have not encountered the
            //beginning of the array
            while (j > 0 && target.compareTo(arr[j - 1]) < 0) {
                //shift elements up list to make room for insertion
                arr[j] = arr[j - 1];
                j--;
            }
            //the location is found;insert target
            arr[j] = target;
        }
    }
}

四.插入排序算法的效率
        假定n是数组的长度，那么插入排序需要n-1遍。对于通用的遍i来说，插入操作从arr[0]到arr[i-1]的子列表中，并且需要平均i/2次比较。比较的平均总数为：
                 T(n) = 1/2 + 2/2 + 3/2 + ...... + (n-2)/2 + (n-1)/2 = n(n-1)/4
        根据T(n)的主项，插入排序算法的平均运行时间为O(n²)。最好情况为O(n)，最坏情况为O(n²)。

Brian 2008-06-11 23:56 发表评论

BlogJava-最爱Java-随笔分类-数据结构与算法

归并排序思路与泛型版本的实现

插入排序思路与泛型版本的实现