数据结构(Java)——查找和排序（3）

一些高级排序算法的Java实现

1. 快速排序

快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，另外其中涉及的分而治之的思想在程序设计中也是一个常用的技巧，因此它是需要认真学习的一个算法重点。快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

1.1 算法分析：

1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。

对挖坑填数进行总结
1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
2．j–由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。 4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

1.2 快速排序的核心算法

    /**
     * 快速排序：通过将列表分区，然后对这两个分区进行递归式排序，从而完成对整个列表的排序
     * 快速排序的策略：
     * 【1】首先，选择一个列表元素作为作为分区元素。
     * 【2】分割该列表，使得小于该分区元素的所有元素位于该元素的左边，所有大于该分区元素的元素位于右边。
     * 【3】最后，将该快速排序策略（递归式）应用于两个分区。
     * @param data
     */
    public static <T extends Comparable<? super T>> void quickSort(T[] data) {
        quickSortRec(data,0,data.length-1);
    }
    /**
     * 需要使用递归的快速排序
     * @param data
     * @param begin
     * @param end
     */
    private static <T extends Comparable<? super T>> void quickSortRec(T[] data,int begin,int end) {
        if(begin<end){
             //int mid = AdjustArray(data, begin, end);//先成挖坑填数法调整data[]  
             int mid = partition(data, begin, end);//先成挖坑填数法调整data[]  
             quickSortRec(data, begin, mid - 1); // 递归调用  
             quickSortRec(data, mid + 1, end);  
        }

    }
    /**
     * 挖坑填数的快速排序的实现
     * @param data
     * @param begin
     * @param end
     * @return
     */
    private static <T extends Comparable<? super T>> int AdjustArray(T[] data,int begin,int end) {
         int i = begin, j = end;  
         T x = data[begin]; //s[l]即s[i]就是第一个坑  
         ///由于是从小到达的排序算法
         ///因此我们首先找一个比基准小的数放在当前的坑里
         while (i < j)  
         {  
             //从右向左找小于x的数来填s[i]   这是找小于基准数的过程
             while(i < j && data[j].compareTo(x)>0)  
                 j--;    

             if(i < j)  
             {  
                 data[i] = data[j]; //将s[j]填到s[i]中，s[j]就形成了一个新的坑  
                 i++;  
             }  
       //------------------------------------------------------------------------------//
             // 从左向右找大于或等于x的数来填s[j]  这是找大于基准数的过程
             while(i < j && data[i].compareTo(x)<0)  
                 i++;    
             if(i < j)  
             {  
              data[j] = data[i]; //将s[i]填到s[j]中，s[i]就形成了一个新的坑  
                 j--;  
             }  
         }  
         //退出时，i等于j。将x填到这个坑中。  
        data[i] = x;      
        return i;

    }
    /**
     * 第二种分割方法的实现
     * @param data
     * @param min
     * @param max
     * @return
     */
    private static <T extends Comparable<? super T>> int partition(T[] data,int min,int max) {

        T pa;
        int left,right;
        int mid = (min+max)/2;
        //将中点的data作为分割元素
        pa=data[mid];
        //将分割元素前置到min处      
        swap(data,mid,min);

        left=min;
        right=max;

        while(left<right){
            while(left<right&&data[left].compareTo(pa)<=0){
                left++;
            }
            while(data[right].compareTo(pa)>0){
                right--;
            }
            if(left<right)
            swap(data,left,right);
        }
        //分割点置回中间位置
        swap(data,min,right);

        return right;
    }

2. 归并排序

2.1 归并排序算法

归并排序是另一种递归排序算法，通过将列表递归式分成两半直至每一个列表都只含有一个元素，然后将这些子列表按照顺序重组，这样就完成了对列表的排序。
归并排序算法的总结：递归划分子列表合并的方式，子列表有序，然后归并到一个列表中完成对列表的归并排序。

2.2 归并排序算法实现

/**
     * 归并排序：归并排序是另一种递归排序算法，通过将列表递归式分成两半直至每一个列表都只含有一个元素，
     * 然后将这些子列表按照顺序重组，这样就完成了对列表的排序。
     * 策略：
     * 【1】首先将该列表分成两个大约相等的部分
     * 【2】对每一个部分列表递归调用其自身，
     * 【3】继续该列表的递归分解，直至达到该递归的基本情形，这是该列表被分割成长度为1的列表
     * @param data
     * @param min
     * @param max
     */
    public static <T extends Comparable<? super T>> void mergeSort(T[] data,
            int min, int max) {
        if (min < max) {
            int mid = (min + max) / 2;
            mergeSort(data, min, mid);
            mergeSort(data, mid + 1, max);
            merge(data, min, mid, max);
        }

    }
    /**
     * Merges two sorted subarrays of the specified array.
     *
     * @param data the array to be sorted
     * @param first the beginning index of the first subarray 
     * @param mid the ending index fo the first subarray
     * @param last the ending index of the second subarray
     */
    private static <T extends Comparable<? super T>> void merge(T[] data,
            int first, int mid, int last) {

        T[] temp = (T[]) (new Comparable[data.length]);

        int first1 = first, last1 = mid; // endpoints of first subarray
        int first2 = mid + 1, last2 = last; // endpoints of second subarray


        int index = first1; // next index open in temp array

        // Copy smaller item from each subarray into temp until one
        // of the subarrays is exhausted
        while (first1 <= last1 && first2 <= last2) {
            if (data[first1].compareTo(data[first2]) < 0) {
                temp[index] = data[first1];
                first1++;
            } else {
                temp[index] = data[first2];
                first2++;
            }
            index++;
        }

        // Copy remaining elements from first subarray, if any
        while (first1 <= last1) {
            temp[index] = data[first1];
            first1++;
            index++;
        }

        // Copy remaining elements from second subarray, if any
        while (first2 <= last2) {
            temp[index] = data[first2];
            first2++;
            index++;
        }

        // Copy merged data into original array
        for (index = first; index <= last; index++)
            data[index] = temp[index];
    }

3. 快排和归并的区别

快速排序和归并排序有点正好相反的意思。
我们以从小到达排序为例：
【1】快速排序的算法是首先执行找中心点，中间大两边小的分割开，然后不断的将列表规模变小，小的在左，大的在右的原则一直不变。这样慢慢的随着列表越变越小就能够实现全部有序。
【2】归并排序的算法是首先将列表递归的一份为二，知道每一个子列表只有一个元素，然后在就近将两个子列表有序合并，列表规模慢慢扩大，这就实现了局部有序到整体有序的过渡。

【3】总之，二者都是递归排序的有效实现，实质上的区别就是，在两个算法的实现过程中一个是先利用分割点通过比较修改表结构，然后再调用递归方法；另一个是先从分割点实现递归调用，然后通过比较实现有序合并。