归并排序问题

最新推荐文章于 2022-09-03 17:08:11 发布

转载最新推荐文章于 2022-09-03 17:08:11 发布 · 552 阅读

26 篇文章

订阅专栏

几十个文件（一共10G），分别保存了很多条数据（一行一条数据），根据其中的每条数据的拼音进行全范围排序。怎么进行？

这应该是典型的 归并排序 问题了吧。只读入一个文件内容到内存应该没问题吧。 

先把每个文件内的拼音 排序好（这时用什么排序算法都行）； 

然后把单个已经排列好的文件，按照 归并排序 算法，每两个合并成一个（合并好的自然也是排序好的）； 
然后再依次合并上一边已经合并好的文件； 
直到合并成一个. 

这时候整个文件都是排序好的，你要是查找的话按顺序查找就行了。用文件指针，按照折半查找算法，应该没问题。 

归并排序 算法网上有，不再copy 到这里了。

如题，一个文本文档，尺寸10G，用java代码给它的内容排序，how to do this?

这个就是外排序了，楼主可以搜索一下，实现过程如下： 

（1）按可用内存的大小，把外存上含有n个记录的文件分成若干个长度为L的子文件，把这些子文件依次读入内存，并利用有效的内部排序方法对它们进行排序，再将排序后得到的有序子文件重新写入外存； 
（2）对这些有序子文件逐趟归并，使其逐渐由小到大，直至得到整个有序文件为止。 
其中，第一个阶段即为内部排序的操作，而第二个阶段涉及到了外部排序中的归并。在前面提到，内存归并排序在开始时是把数组中的每个元素均看作是长度为1的有序表，在归并过程中，有序表的长度从1开始，依次为2、4、8、……，直至有序表的长度len大于等于待排序的记录数n为止。而在对外存文件的归并排序中，初始有序表的长度通常是从一个确定的长度开始而不是从1开始，这是为了能够有效地减少归并的趟数和访问外存的次数，以提高外部排序的效率。所以，在第一阶段要按照初始有序表确定的长度在原文件上依次建立好每个有序表，在第二个阶段再调用对文件的归并排序算法完成排序。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。
 
  
   
    [cpp] 
    view plain
    copy
    
   
  
  //将有序数组a[]和b[]合并到c[]中  
void MemeryArray(int a[], int n, int b[], int m, int c[])  
{  
    int i, j, k;  
  
    i = j = k = 0;  
    while (i < n && j < m)  
    {  
        if (a[i] < b[j])  
            c[k++] = a[i++];  
        else  
            c[k++] = b[j++];   
    }  
  
    while (i < n)  
        c[k++] = a[i++];  
  
    while (j < m)  
        c[k++] = b[j++];  
}  
 
可以看出合并有序数列的效率是比较高的，可以达到O(n)。
解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？
可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。
 
  
   
    [cpp] 
    view plain
    copy
    
   
  
  //将有二个有序数列a[first...mid]和a[mid...last]合并。  
void mergearray(int a[], int first, int mid, int last, int temp[])  
{  
    int i = first, j = mid + 1;  
    int m = mid,   n = last;  
    int k = 0;  
      
    while (i <= m && j <= n)  
    {  
        if (a[i] <= a[j])  
            temp[k++] = a[i++];  
        else  
            temp[k++] = a[j++];  
    }  
      
    while (i <= m)  
        temp[k++] = a[i++];  
      
    while (j <= n)  
        temp[k++] = a[j++];  
      
    for (i = 0; i < k; i++)  
        a[first + i] = temp[i];  
}  
void mergesort(int a[], int first, int last, int temp[])  
{  
    if (first < last)  
    {  
        int mid = (first + last) / 2;  
        mergesort(a, first, mid, temp);    //左边有序  
        mergesort(a, mid + 1, last, temp); //右边有序  
        mergearray(a, first, mid, last, temp); //再将二个有序数列合并  
    }  
}  
  
bool MergeSort(int a[], int n)  
{  
    int *p = new int[n];  
    if (p == NULL)  
        return false;  
    mergesort(a, 0, n - 1, p);  
    delete[] p;  
    return true;  
}  
 
 
归并排序的效率是比较高的，设数列长为N，将数列分开成小数列一共要logN步，每步都是一个合并有序数列的过程，时间复杂度可以记为O(N)，故一共为O(N*logN)。因为归并排序每次都是在相邻的数据中进行操作，所以归并排序在O(N*logN)的几种排序方法（快速排序，归并排序，希尔排序，堆排序）也是效率比较高的。
 
在本人电脑上对冒泡排序，直接插入排序，归并排序及直接使用系统的qsort()进行比较（均在Release版本下）
对20000个随机数据进行测试：
对50000个随机数据进行测试：
再对200000个随机数据进行测试：
 
注：有的书上是在mergearray()合并有序数列时分配临时数组，但是过多的new操作会非常费时。因此作了下小小的变化。只在MergeSort()中new一个临时数组。后面的操作都共用这一个临时数组。