C语言编程常见问题解答之排序与查找

                                    第3章  排序与查找

    在计算机科学中，排序(sorting)是研究得最多的问题之一，许多书籍都深入讨论了这个问题。本章仅仅是一个介绍，重点放在C语言的实际应用上。

    排 序

    程序员可以使用的基本排序算法有5种：
    ·插入排序(insertionsort．)
    ·交换排序(exchangesOrt)
    ·选择排序(selectionsort)   
    ·归并排序(mergesort)
    ·分布排序(distributionsort)

    为了形象地解释每种排序算法是怎样工作的，让我们来看一看怎样用这些方法对桌上一付乱序的牌进行排序。牌既要按花色排序(依次为梅花、方块、红桃和黑心)，还要按点数排序(从2到A)。
    插入排序的过程为：从一堆牌的上面开始拿牌，每次拿一张牌，按排序原则把牌放到手中正确的位置。桌上的牌拿完后，手中的牌也就排好序了。
    交换排序的过程为：
    (1)先拿两张牌放到手中。假如左边的牌要排在右边的牌的后面，就交换这两张牌的位置。
    (2)然后拿下一张牌，并比较最右边两张牌，假如有必要就交换这两张牌的位置。
    (3)重复第(2)步，直到把所有的牌都拿到手中。
    (4)假如不再需要交换手中任何两张牌的位置，就说明牌已经排好序了；否则，把手中的牌放到桌上，重复(1)至(4)步，直到手中的牌排好序。
    选择排序的过程为：在桌上的牌中找出最小的一张牌，拿在手中；重复这种操作，直到把所有牌都拿在手中。
    归并排序的过程为：把桌上的牌分为52堆，每堆为一张牌。因为每堆牌都是有序的(记住，此时每堆中只有一张牌)，所以假如把相邻的两堆牌合并为一堆，并对每堆牌进行排序，就可以得到26堆已排好序的牌，此时每一堆中有两张牌。重复这种合并操作，就可以依次得到13堆牌(每一堆中有4张牌)，7堆牌(有6堆是8张牌，还有一堆是4张牌)，最后将得到52张的一堆牌。
    分布排序(也被称作radix sort，即基数排序)的过程为：先将牌按点数分成13堆，然后将这13堆牌按点数顺序叠在一起；再将牌按花色分成4堆，然后将这4堆牌按花色顺序叠在一起，牌就排好序了。
    在选用排序算法时，你还需要了解以下几个术语：
    (1)自然的(natural)
    假如某种排序算法对有序的数据排序速度较快(工作量变小)，对无序的数据排序速度却较慢(工作变量大)，我们就称这种排序算法是自然的。假如数据已接近有序，就需要考虑选用自然的排序算法。
    (2)稳定的(stable)
    假如某种排序算法能保持它认为相等的数据的前后顺序，我们就称这种排序算法是稳定的。    
    例如，现有以下名单：
    Mary Jones
    Mary Smith
    Tom Jones
    Susie Queue
    假如用稳定的排序算法按姓对上述名单进行排序，那么在排好序后"Mary Jones”和"Tom Jones”将保持原来的Jr顺序，因为它们的姓是相同的。
    稳定的排序算法可按主、次要害字对数据进行排序，例如按姓和名排序(换句话说，主要按姓排序，但对姓相同的数据还要按名排序)。在具体实现时，就是先按次要害字排序，再按主要害字排序。
    (3)内部排序(internal sort)和外部排序(external sort)
    待排数据全部在内存中的排序方法被称为内部排序，待排数据在磁盘、磁带和其它外存中的排序方法被称为外部排序。

    查 找

    和排序算法一样，查找(searching)算法也是计算机科学中研究得最多的问题之一。查找算法和排序算法是有联系的，因为许多查找算法依靠于要查找的数据集的有序程度。基本的查找算法有以下4种：
    ·顺序查找(sequential searching)。
    ·比较查找(comparison searching)
    ·基数查找(radix searching)
    ·哈希查找(hashing)   
    下面仍然以一付乱序的牌为例来描述这些算法的工作过程。
    顺序查找的过程为：从第一张开始查看每一张牌，直到找到要找的牌。
    比较查找(也被称作binarysearching，即折半查找)要求牌已经排好序，其过程为：任意抽一张牌，假如这张牌正是要找的牌，则查找过程结束。假如抽出的这张牌比要找的牌大，则在它前面的牌中重复查找操作；反之，则在它后面的牌中重复查找操作，直到找到要找的牌。
    基数查找的过程为：先将牌按点数分成13堆，或者按花色分成4堆。然后找出与要找的牌的点数或花色相同的那一堆牌，再在这堆牌中用任意一种查找算法找到要找的牌。
    哈希查找的过程为：
    (1)在桌面上留出可以放若干堆牌的空间，并构造一个函数，使其能根据点数和花色将牌映射到特定的堆中(这个函数被称为hashfunction，即哈希函数)。
    (2)根据哈希函数将牌分成若干堆。   
    (3)根据哈希函数找到要找的牌所在的堆，然后在这一堆牌中找到要找的牌。   
    例如，可以构造这样一个哈希函数：   
  pile=rank+suit
    其中，rank是表示牌的点数的一个数值；suit是表示牌的花色的一个数值；pile表示堆值，它将决定一张牌归入到哪一堆中。假如用1，2，……，13分别表示A，2，……．K，用0，1，2和3分别表示梅花、方块、红桃和黑桃，则pile的值将为1，2，……，16，这样就可以把一付牌分成16堆。
    哈希查找虽然看上去有些离谱，但它确实是一种非常实用的查找算法。各种各样的程序，从压缩程序(如Stacker)到磁盘高速缓存程序(如SmartDrive)，几乎都通过这种方法来提高查找速度，
   
  排序或查找的性能
   
  有关排序和查找的一个主要问题就是速度。这个问题经常被人们忽视，因为与程序的其余部分相比，排序或查找所花费的时间几乎可以被忽略。然而，对大多数排序或查找应用来说，你不必一开始就花很多精力去编制一段算法程序，而应该先在现成的算法中选用一种最简单的(见3．1和3．4)，当你发现所用的算法使程序运行很慢时，再换用一种更好的算法(请参见下文中的介绍)。
    下面介绍一种判定排序或查找算法的速度的方法。
    首先，引入一个算法的复杂度的概念，它指的是在各种情况(最好的、最差的和平均的)下排序或查找需要完成的操作次数，通过它可以比较不同算法的性能。
    算法的复杂度与排序或查找所针对的数据集的数据量有关，因此，引入一个基于数据集数据量的表达式来表示算法的复杂度。
    最快的算法的复杂度O(1)，它表示算法的操作次数与数据量无关。复杂度O(N)(N表示数据集的数据量)表示算法的操作次数与数据量直接相关。复杂度O(logN)介于上述两者之间，它表示算法的操作次数与数据量的对数有关。复杂度为O(NlogN)(N乘以logN)的算法比复杂度为O(N)的算法要慢，而复杂度为O(N²)的算法更慢。
    注重：假如两种算法的复杂度都是O(logN)，那么logN的基数较大的算法 的速度要快些，在本章的例子中，logN的基数均为10。

        表3．1  本章所有算法的复杂度
-----------------------------------------------------------------
    算    法    最好情况    平均情况    最坏情况
-----------------------------------------------------------------
  快速排序      O(NlogN)    O(NlogN)    O(N²)
  归并排序      O(N)        O(NlogN)    O(NlogN)
  基数排序      O(N)        O(N)        O(N)   
  线性查找                  O(N)
  折半查找                  O(NlogN)
  哈希查找                  O(N/M)*
  健树查找                  O(1)**
-----------------------------------------------------------------
* M是哈希表项的数目
** 实际上相当于有2³²个哈希表项的哈希查找

    表3. 1列出了本章所有算法的复杂度。对于排序算法，表中给出了最好的、平均的和最差的情况下的复杂度，平均情况是指数据随机排列的情况；排序算法的复杂度视数据的初始排列情况而定，它一般介于最好的和最差的两种情况之间。对于查找算法，表中只给出了平均情况下的复杂度，在最好的情况(即要找的数据恰好在第一次查找的位置)下，查找算法的复杂度显然是O(1)；在最坏的情况(即要找的数据不在数据集中)下，查找算法的复杂度通常与平均情况下的复杂度相同。   
    需要注重的是，算法的复杂度只表示当N值变大时算法的速度变慢的程度，它并不表示算法应用于给定大小的数据集时的实际速度。算法的实际速度与多种因素有关，包括数据集的数据类型以及所用的编程语言、编译程序和计算机等。换句话说，与复杂度高的算法相比，复杂度低的算法并不具备绝对的优越性。实际上，算法的复杂度的真正意义在于，当N值大于某一数值后，复杂度低的算法就会明显比复杂度高的算法快。
    为了说明算法的复杂度和算法的实际执行时间之间的关系，表3．2列出了本章所有例子程序的执行时间。本章所有例子程序均在一台以Linux为操作系统的90MHz奔腾计算机上由GNU C编译程序编译，在其它操作系统中，这些例子程序的执行时间与表3．2所列的时间是成比例的。

                 表3. 2  本章所有例子程序的执行时间
---------------------------------------------------------------------------
    例子程序    算  法      2000      4000      6000      8000      10000
---------------------------------------------------------------------------
    例3．1     qsort()      0．02     0．05     0．07     0．11     0，13
    例3．2a    快速排序     0．02     0．07     0．13     0．18     0．20
    例3．2b    归并排序     0．03     0．08     0．14     0．18     0．26
    例3．2c    基数排序     0．07     0．15     0．23     0．30     0．39
    例3．4     bsearch()    0. 37     0．39     0．39     0．40     0．41
    例3．5     折半查找     0．32     0．34     0．34     0．36     0．36
    例3．6     线性查找     9．67     20．68    28．71    36．31    45. 51
    例3．7     键树查找     0．27     0．28     0．29     0．29     0．30
    例3．8     哈希查找     0．25     0．26     0．28     0．29     0．28
---------------------------------------------------------------------------

 注重：(1)表中所列的时间以秒为单位。(2)表中所列的时间经过统一处理，只包括排序或查找所花费的时间。(3)2000等数值表示数据集的数据量。(4)数据集中的数据是从文件／usr／man／manl／gcc．1(GNUC编译程序中的一个文件)中随机提取的词。(5)在查找算法中，要查找的数据是从文件／usr／man／manl／g++．1(GNUC++编译程序中的一个文件)中随机提取的词。(6)函数qsort()和bseareh()分别是C标准库函数中用于快速排序算法和折半查找算法的函数，其余例子程序是专门为本章编写的。
    在阅读完以上内容后，你应该能初步体会到如何根据不同的情况来选用一种合适的排序或查找算法。在Donald E．Knuth所著的《The Art Of Computer Programming，Volume 3，Sorting and Searching》一书中，作者对排序和查找算法进行了全面的介绍，在该书中你将读到更多关于复杂度和复杂度理论的内容，并且能见到比本章中所提到的更多的算法。

    公用代码
    本章中的许多例子程序是可以直接编译运行的。在这些例子程序中，许多代码是相同的， 这些相同的代码将统一在本章的末尾列出。

    3．1  哪一种排序方法最方便?
    答案是C标准库函数qsort()，理由有以下三点：
    (1)该函数是现成的；   
    (2)该函数是已通过调试的；
    (3)该函数通常是已充分优化过的。
    qsort()函数通常使用快速排序算法，该算法是由C. A．R．Hoare于1962年提出的。以下是qsort()函数的原型：
    void qsort(void *buf，size_t hum，size_t size，
    int(*comp)(const void *ele1，const void *ele2));

    qsort()函数通过一个指针指向一个数组(buf)，该数组的元素为用户定义的数据，数组的元素个数为num，每个元素的字节长度都为size。数组元素的排序是通过调用指针comp所指向的一个函数来实现的，该函数对数组中由ele1和ele2所指向的两个元素进行比较，并根据前者是小于、等于或大于后者而返回一个小于、等于或大于0的值。  
    例3．1中给出了一个函数sortStrings()，该函数就是通过qsort()函数对一个以NULL指针结束的字符串数组进行排序的。将例3．1所示的代码和本章结尾的有关代码一起编译成一个可执行程序后，就能按字母顺序对一个以NULL指针结束的字符串数组进行排序了。

1:#include<stdlib. h>
 2:
 3: /*
 4:  * This routine is used only by sortStrings(), to provide a
 5:  * string comparison {unction to pass to qsort().
 6:  */
 7: static int comp(const void * elel, const void * ele2)
 8: {
 9:    return strcmp( * (const char * * ) ele1,
10:                * (const char * * ) ele2);
11: }
12:
13: / * Sort strings using the library function qsort() * /
14: void sortStrings(const char * array[-'])
15: {
16,       /* First, determine the length of the array * /
17:       int num;
18:
19:      for (num=O; array[num]; num++)
20:
21:      qsort(array, num, sizeof( * array), comp) ;
22: }

 在例3．1中，第19行和第20行的for循环语句用来计算传递给qsort()函数的数组元素个数，函数comp()的作用是将函数qsort()传递给它的类型(const void *)转换为函数strcmp()
所要求的类型(const char *)。因为在函数qsort()中，ele1和ele2是指向数组元素的指针，而在例3．1中这些数组元素本身也是指针，因此，应该先将ele1和ele2转换为const char **类型，然后在转换结果前加上指针运算符“*”，才能得到函数strcmp()所要求的类型。
    尽管有qsort ()函数，但程序员经常还要自己编写排序算法程序，其原因有这样几点：第一，在有些异常情况下，qsort()函数的运行速度很慢，而其它算法程序可能会快得多；第二，qsort()函数是为通用的目的编写的，这给它带来了一些不利之处，例如每次比较时都要通过用户提供的一个函数指针间接调用一个函数；第三，由于数组元素的长度在程序运行时才能确定下来，因此用来在数组中移动数组元素的那部分代码没有针对数组元素长度相同的情况进行优化；第四，qsort()函数要求所有数据都在同一个数组中，而在实际应用中，数据的长度和性质千变万化，可能很难甚至无法满足这一要求；第五，qsort()函数通常不是一种稳定的排序方法。

    请参见： 
    3．2 哪一种排序方法最快?
    3．3 当要排序的数据集因太大而无法全部装入内存时，应怎样排序?
    3．7 怎样对链表进行排序?
    7．1 什么是间接引用(indirection)?
    7，2 最多可以使用几层指针?
    7．5 什么是void指针?    ·
    7．6 什么时候使用void指针?

    3．2 哪一种排序方法最快?
    首先，对大多数包含排序应用的程序来说，排序算法的速度并不重要，因为在程序中排序  的工作量并不是很多，或者，与排序相比，程序中其它操作所花费的时间要多得多。
    实际上，没有哪一种排序算法永远是最快的，在运行程序的软硬件环境相同的情况下，不同排序算法的速度还与数据的长度、性质以及数据的初始顺序有关。
    在笔者的“工具箱”中，有三种算法在不同的情况下都是最快、最有用的，这三种算法分别是快速排序、归并排序和基数排序。
    快速排序
    快速排序是一种分割处理式的排序算法，它将一个复杂的排序问题分解为若干较轻易处理的排序问题，然后逐一解决。在快速排序算法中，首先要从数据集的数据中选择一个数据作为分割值，然后将数据分成以下3个子集：
    (1) 将大于分割值的数据移到分割值前面，组成子集1；
    (2) 分割值本身为子集2；   
    (3) 将小于分割值的数据移到分割值后面，组成子集3。
    等于分割值的数据可以放在任意一个子集中，这对快速排序算法没有任何影响。
    由于子集2已经是有序的，所以此后只需对子集1和子集3进行快速排序。
    需要注重的是，当数据集很小时，无法进行快速排序，而要使用其它排序算法。显然，当数据集中的数据只有两个或更少时，就不可能将数据集再分割成三个子集。实际上，当数据集比
较小时，程序员就应该考虑是否仍然采用快速排序算法，因为在这种情况下另外一些排序算法往往更快。
    例3. 2a用快速排序算法重写了例3．1中的字符串数组排序程序，你同样可以将它和本章末尾的有关代码一起编译成一个可执行程序。程序中定义了一个宏，它可使程序更易读，并能加快执行速度。
    快速排序算法是由程序中的myQsort()函数实现的，它是按升序对一个字符串数组进行排序的。函数myQsort()的具体工作过程如下：
    (1)首先检查最简单的情况。在第17行，检查数组中是否没有或只有一个元素——在这种情况下，数组已经是有序的，函数就可以返回了。在第19行，检查数组中是否只有两个元素——在这种情况下，要么数组已经是按升序排列的，要么交换这两个元素的位置，使它们按升序排列。
    (2)在第28行至第53行，将数组分割为两个子集：第一个子集中的数据大于或等于分割值，第二个子集中的数据小于分割值。
    在第28行，选择数组中间的元素作为分割值，并将其和数组中的第一个元素交换位置。
    在第37行至第39行，在数组中找到属于第二个子集的第一个元素；在第45行至第47行，在数组中找到属于第一个子集的最后一个元素。
    在第49行，检查属于第二个子集的第一个元素是否位于属于第一个子集的最后一个元素的后面，假如是，则第一个子集的所有元素都已在第二个子集的所有元素的前面，数据已经划分好了；否则，交换这两个元素的位置，然后重复上述这种检查。
    (3)当两个子集分割完毕后，在第55行，将分割值和第一个子集中的最后一个元素交换位置，排序结束时这个分割值将仍然排在现在这个位置。在第57行和第58行，分别调用myQsort()函数对分割所得的子集进行排序。当所有的子集都经过排序后，整个数组也就排好序了。

    例3. 2a一个不使用qsort()函数的快速排序算法程序

 1: #include <stdlib.h>
 2:
 3: #define exchange(A, B, T)  ((T) = (A), (A) = (B),(B)=(T))
 4:                                       
 5:
 6: / * Sorts an array of strings using quick sort algorithm * /
 7: static void myQsort(const char * array[], size_t num)
 8: {
 9:     const char * temp
10:     size_t i, j;
11:
12:       /*
13:       * Check the simple cases first:
14:       * If fewer than 2 elements, already sorted
15:       * If exactly 2 elements, just swap them (if needed).
16:          * /
17:       if (num <2)
18:                return;
19:       else if (num==2)
20:        {
21:           if (strcmp(array[O], array[1])>O)
22:                 exchange (array[0], array[1] ,temp)
23:        }
24:        / *
25:        * Partition the array using the middle (num/2)
26:        element as the dividing element.
27:          * /
28:       exchange (array[0], array[num / 2], temp)
29:       i=1;
30:       j=num;
31:       for (; ;)
32:         {
33:             / *
34:               * Sweep forward until and element is found that
35:               * belongs in the second partition.
36:               * /
37:              while (i<j && strcmp (array[i], array[0])
38:                                                   <=0)
39:                    i++;
40:              / *
41:                * Then sweep backward until an element
42:                * is found that belongs in the first
43:                * partition.
44:                * /
45:             while (i<j&& strcmp(array[j-1], array[O]
46:                                               >=0)
47:                  j--;
48:              / * If no out-of-place elements, you're done * /
49:            if (i>=j)
50:                  break
51:               / * Else, swap the two out-of-place elements * /
52:              exchange(array[i], array[j-l], temp)
53:        }
54:       / * Restore dividing element * /
55:       exchange(array[O], array[i-1], temp)
56:       / * Now apply quick sort to each partition * /
57:       myQsort (array, i-1 )
58:       myQsort (array + i, num-i)
59:  }
60:
61: / * Sort strings using your own implementation of quick sort * /
62: void sortStrings (char * array[])
63: {
64:       / * First, determine the length of the array * /
65:       int num
66:
67:       for (num = O; array[num] ; num++ )
68:
69:       myQsort((void * ) array, num)
70: }


   归并排序
    归并排序也是一种分割处理式的排序算法 ，它是由Johnyon Neumann于1945年提出的。
    在归并排序算法中，将待排序数据看作是一个链表序列，每个链表(最坏的情况下每个链表中只有一个元素)中的数据都已经排好序，然后不断地将相邻的链表合并为一些较大的链表，当所有的链表都合并为一个链表时，排序过程也就结束了。归并排序算法非凡适合于对键表或其它非数组形式的数据结构进行排序，它还能对无法放入内存的数据进行排序；或者被作为一种特定的排序算法来使用。
    例3．2b是实现归并排序算法的一个例子，你可以将它和本章结尾的有关代码一起编译成一个可执行程序。有关list_t类型及其操作函数的代码也已在本章末尾列出。 
    在例3．2b中，字符串被存放在一个链表中，而不是一个数组中。实际上，将数据组织为链表后更利于归并排序算法对其进行处理，因为数组中的元素是无法合并的，除非利用另外分配的内存空间。
    例3．2b通过以下4个函数共同实现归并排序算法：   
    (1)split()函数
    split()函数将一个字符串链表分割为一个由多个字符串链表组成的链表，其中每一个字符串链表都已经是排好序的。例如，假如初始链表为("the" "quick""brown" "fox")，则split()函数将返回一个由3个链表组成的链表，这3个链表分别为(“the”)，("quick”)和("brown”“fox”)。因为字符串“brown”和“fox”已经是排好序的，所以它们被放到一个链表中。
    尽管split()函数将初始链表分割为一系列只含一个数据的链表后，本例的排序算法仍然能很好地执行，但是，假如初始链表中的数据已经接近有序，那么在分割初始链表时，将相邻的有序数据放到同一个链表中，就能大大减少以后的工作量，从而使本例的排序算法成为自然的排序算法(见本章开始部分中的介绍)。
    当输入链表不为空时，程序第14—24行的循环将一直进行下去。在每次循环中，程序第16行将构造一个新的链表；第17—22行将把输入链表中的元素不断地移到所构造的链表之中，直到处理完输入链表中的所有元素，或者检查到两个无序的元素；第23行将把所构造的链表添加到输出链表(它的数据也是链表)中。
    (2)merge()函数
    merge()函数将两个数据已经有序的链表合并为一个数据有序的链表。
    当正在合并的两个链表都不为空时，程序第37—45行的循环将一直进行下去。第40行的if 语句将比较两个链表中的第一个元素，并把较小的元素移到输出链表中。当正在合并的两个链表中有一个为空时，另一个链表中的元素必须全部添加到输出链表中。第46行和第47行将已为空的链表和另一个链表与输出链表链接上，从而结束整个合并过程。
    (3)mergePairs()函数
    通过调用merge()函数，mergePairs()函数分别对一个由字符串链表组成的链表中的每个对链表进行合并，并用合并所得的链表代替原来的那对链表。
    当输入链表不为空时，程序第61—77行的循环将一直进行下去。第63行的if语句检查输入链表中是否至少有两个字符串链表，假如没有，第76行就把这个单独的链表添加到输出链表中；假如有，第65行和第66行将从输入链表中选出头两个链表，第68行和69行将合并这两个链表，第72行将把合并所得的链表添加到输出链表中，第70行、第71行和第73行将释放所分配的过渡性结点，第72行和第73行将从输入链表中删去头两个链表。
    (4)sortStrings()函数
    sonStrings()函数对一个字符串数组进行归并排序。
    程序第88行和第89行将字符串数组转换为一个字符串链表。第90行调用split()函数将初始链表分割为一个由字符串链表组成的链表。第91行和第92行调用mereePairs()函数将分割所得的链表中的所有字符串链表合并为一个字符串链表。第93行检查合并所得的链表是否为空(当原来的字符串数组中只有。个元素时该链表为空)，若不为空，才能将该链表从分割所得的链表中移出。
    需要注重的是，sortStrings()函数没有释放它所用过的内存。   

    例3．2b一个归并排序算法程序
 1. #include<stdlib.h>
 2: #include "list.h"
 3:
 4: /*
 5:  * Splits a list of strings into a list of lists of strings
 6:  * in which each list of strings is sorted.
 7:  */
 8: static list-t split(list_t in)
 9: {
10:      list-t out
11:      list-t * curr;
12:      out. head=out, tail=NULL;
13:
14:      while (in. head)
15:      {
16:           curr =newList();
17:           do
18:           {
19:                appendNode (curr, removeHead (&in));
20:           }
21:         while (in. head && strcmp (curr->tail->u. str,
22:                             in. head->u.str) < = 0);
23:         appendNode(&out, newNode(curr));
24:     }
25:     return Out;
26: }
27:
28: /*
29:  * Merge two sorted lists into a third sorted list,
30:  *.which is then returned.
31:  * /
32: static list_t merge (list_t first, list_t second)
33: {
34:         list_t out;
35:         out.head=out, tail=NULL;
36:
37:         while (first. head && second, head)
38:           {
39:                 listnode_t * temp;
40:                 if (strcmp (first. head->u.str,
41:                        second. head->u.str) <=0)
42:                      appendNode(&out, removeHead(&first));
43:                  else
44:                       appendNode (&out, removeHead (&second));
45:           }
46:         concatList (&out, &first);
47:         concatList (&out, &second);
48:         return out;
49: }
50:
51: /*
52:  * Takes a list of lists 0{ strings and merges'each pair of
53:  * lists into a single list. The resulting list has 1/2 as
54:  * many lists as the original.
55:  * /
56: static list_t mergePairs(list_t in)
57: {
58:      list_ t out;
59:      out. head:out, tail=NUll;
60:
61:      while (in. head)
62:      {
63:           if (in. head->next)
64:           {
65:                  list_t * first =in. head->u.list;
66:                  list_t * second;
67:                              in.head->next->u.list
68:                  in. head->u.list = copyOf (merge ( * first,
69:                                                           * second));
70:                  free (first);
71:                  free (second);
72:                  appendNode (&out, removeHead (&in))
73:                  free (removeHead (&in));
74:             }
75:             else
76:                 appendNode (&out, removeHead (&in));
77:      }
78:      return out
79: }
80:
81: / * Sort strings using merge sort * /
82: void sortStrings (const char * array[])
83: {
84:         int i;
85:         list_t out;
86:         out.head=out, tail=NULL;
87:
88:          for (i=0; array[i]; i++)
89:             appendNode(&out, newNode((void * ) array[i]))
90:          out= split (out);
91:         while (out.head ! =out.tail)
92:             out = mergePairs (out);
93:         if (ou t.head)
94:                  out = * out.head->u.list;
95:        for (i=O; array[i]; i++)
96:                array[i] = removeHead (&out)->u.str;
97: }