• 示例
    • sort
    • 集合
    • 素数

    示例

    在以下章节中我们将给出一些稍微复杂一些的列表处理函数的使用示例。

    sort

    程序3.1是著名的快速排序的一个变体。sort(X)对列表X的元素排序，将结果放入一个新列表并将之返回。

    程序3.1

    1. -module(sort).
    2. -export([sort/1]).
    3.  
    4. sort([]) -> [];
    5. sort([Pivot|Rest]) ->
    6.     {Smaller, Bigger} = split(Pivot, Rest),
    7.     lists:append(sort(Smaller), [Pivot|sort(Bigger)]).
    8.  
    9. split(Pivot, L) ->
    10.     split(Pivot, L, [], []).
    11.  
    12. split(Pivot, [], Smaller, Bigger) ->
    13.     {Smaller,Bigger};
    14. split(Pivot, [H|T], Smaller, Bigger) when H < Pivot ->
    15.     split(Pivot, T, [H|Smaller], Bigger);
    16. split(Pivot, [H|T], Smaller, Bigger) when H >= Pivot ->
    17.     split(Pivot, T, Smaller, [H|Bigger]).

    此处选取列表的第一个元素为中轴。元列表被分为两个列表Smaller和Bigger：Smaller的所有元素都小于中轴Pivot而Bigger的所有元素都大于等于Pivot。之后，再对列表Smaller和Bigger分别排序并将结果合并。

    函数split({Pivot,L})返回元组{Smaller,Bigger}，其中所有Bigger中的元素都大于等于Pivot而所有Smaller中的元素都小于Pivot。split(Pivot,L)通过调用一个辅助函数split(Pivot,L,Smaller,Bigger)完成任务。两个累加列表，Smaller和Bigger分别用于存储L中小于和大于等于Pivot的元素。split/4的代码与reverse/2非常相像，只是多用了一个累加列表。例如：

    1. > lists:split(7,[2,1,4,23,6,8,43,9,3]).
    2. {[3,6,4,1,2],[9,43,8,23]}

    如果我们调用sort([7,2,1,4,23,6,8,43,9,3])，首先就会以7为中轴来调用split/2。这将产生两个列表：所有元素都小于中轴7的[3,6,4,1,2]，以及所有元素都大于等于中轴的[9,43,8,23]。

    假设sort工作正常，则sort([3,6,4,1,2])⇒[1,2,3,4,6]而sort([9,43,8,23])⇒[8,9,23,43]。最后，排好序的列表被拼装在一起：

    1. > append([1,2,3,4,6], [7 | [8,9,23,43]]).
    2. [1,2,3,4,6,7,8,9,23,43]

    再动一点脑筋，都append的调用也可以省掉，如下所示：

    1. qsort(X) ->
    2.     qsort(X, []).
    3.  
    4. %% qsort(A,B)
    5. %%   Inputs:
    6. %%      A = unsorted List
    7. %%      B = sorted list where all elements in B
    8. %%          are greater than any element in A
    9. %%   Returns
    10. %%      sort(A) appended to B
    11.  
    12. qsort([Pivot|Rest], Tail) ->
    13.     {Smaller,Bigger} = split(Pivot, Rest),
    14.     qsort(Smaller, [Pivot|qsort(Bigger,Tail)]);
    15. qsort([], Tail) ->
    16.     Tail.

    我们可以利用BIFstatistics/1（用于提供系统性能相关的信息，参见附录??）将之与第一版的sort做一个对比。如果我们编译并执行以下代码片段：

    1. ...
    2. statistics(reductions),
    3. lists:sort([2,1,4,23,6,7,8,43,9,4,7]),
    4. {_, Reductions1} = statistics(reductions),
    5. lists:qsort([2,1,4,23,6,7,8,43,9,4,7]),
    6. {_, Reductions2} = statistics(reductions),
    7. ...

    我们可以得知sort和qsort的归约（函数调用）次数。在我们的示例中sort花费93次归约，而qsort花费74次，提升了百分之二十。

    集合

    程序3.2是一组简单的集合操作函数。在Erlang中表示集合的最直白的方法就是采用一个不包含重复元素的无序列表。

    集合操作函数如下：

    new()
    返回一个空集合。
    add_element(X,S)
    返回将元素X并入集合S 产生的新集合。
    del_element(X,S)
    返回从集合S中删去元素X的新集合。
    is_element(X,S)
    当元素X在集合S中时返回true，否则返回false。
    is_empty(S)
    当集合S为空集时返回true，否则返回false。
    union(S1,S2)
    返回集合S1和S2的并集，即包含了S1或S2所有元素的集合。
    intersection(S1,S2)
    返回集合S1和S2的交集，即仅包含既包含于S1又包含于S2的元素的集合。

    严格地说，我们并不能说new返回了一个空集，而应该说new返回了一个空集的表示。如果我们将集合表示为列表，则以上的集合操作可以编写如下：

    程序3.2

    1. -module(sets).
    2. -export([new/0, add_element/2, del_element/2,
    3.          is_element/2, is_empty/1, union/2, intersection/2]).
    4.  
    5. new() -> [].
    6.  
    7. add_element(X, Set) ->
    8.     case is_element(X, Set) of
    9.         true -> Set;
    10.         false -> [X|Set]
    11.     end.
    12.  
    13. del_element(X, [X|T]) -> T;
    14. del_element(X, [Y|T]) -> [Y|del_element(X,T)];
    15. del_element(_, [])    -> [].
    16.  
    17. is_element(H, [H|_])   -> true;
    18. is_element(H, [_|Set]) -> is_element(H, Set);
    19. is_element(_, [])      -> false.
    20.  
    21. is_empty([]) -> true;
    22. is_empty(_)  -> false.
    23.  
    24. union([H|T], Set) -> union(T, add_element(H, Set));
    25. union([], Set)    -> Set.
    26.  
    27. intersection(S1, S2)       -> intersection(S1, S2, []).
    28. intersection([], _, S)     -> S;
    29. intersection([H|T], S1, S) ->
    30.     case is_element(H,S1) of
    31.         true -> intersection(T, S1, [H|S]);
    32.         false -> intersection(T, S1, S)
    33.     end.

    运行程序3.2的代码：

    1. > S1 = sets:new().
    2. []
    3. > S2 = sets:add_element(a, S1).
    4. [a]
    5. > S3 = sets:add_element(b, S2).
    6. [b,a]
    7. > sets:is_element(a, S3).
    8. true
    9. > sets:is_element(1, S2).
    10. false
    11. > T1 = sets:new().
    12. []
    13. > T2 = sets:add_element(a, T1).
    14. [a]
    15. > T3 = sets:add_element(x, T2).
    16. [x,a]
    17. > sets:intersection(S3, T3).
    18. [a]
    19. 10> sets:union(S3,T3).
    20. [b,x,a]

    这个实现并不十分高效，但足够简单以保证其正确性（但愿如此）。今后还可以将之替换为一套更高效的实现。

    素数

    在我们的最后一个例子（程序3.3）中，我们将来看看如何使用埃拉托色尼筛法来生成一张素数表。

    程序 3.3

    1. -module(siv).
    2. -compile(export_all).
    3.  
    4. range(N, N) ->
    5.     [N];
    6. range(Min, Max) ->
    7.     [Min | range(Min+1, Max)].
    8.  
    9. remove_multiples(N, [H|T]) when H rem N == 0 ->
    10.     remove_multiples(N, T);
    11. remove_multiples(N, [H|T]) ->
    12.     [H | remove_multiples(N, T)];
    13. remove_multiples(_, []) ->
    14.     [].
    15.  
    16. sieve([H|T]) ->
    17.     [H | sieve(remove_multiples(H, T))];
    18. sieve([]) ->
    19.     [].
    20.  
    21. primes(Max) ->
    22.     sieve(range(2, Max)).

    注意在程序3.3中我们使用了编译器标注-compile(export_all)——这将隐式地导出该模块中的所有函数，于是我们无须显式地给出导出申明便可以调用这些函数。

    range(Min,Max)返回一个包含从Min到Max的所有整数的列表。

    remove_multiples(N,L)从列表L删除中N的倍数：

    1. > siv:range(1,15).
    2. [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
    3. > siv:remove_multiples(3,[1,2,3,4,5,6,7,8,9,10]).
    4. [1,2,4,5,7,8,10]

    sieve(L)保留列表L的头部，对于尾部的列表，则再递归地删除其头部的所有倍数：

    1. > siv:primes(25).
    2. [2,3,5,7,11,13,17,19,23]