erlang中並行快速排序的問題

Question

我在erlang中編寫quicksort時遇到問題。 我正在做的是我產生兩個進程，然后阻止當前進程，直到我從左右子陣列得到響應。 獲取這兩個響應后，我向其父級發送一條消息，為其提供計算列表。 Parent ! {self(), Lone ++ [H] ++ Ltwo}

但是我在兩個子流程中都遇到了取消undef的錯誤。 這是代碼。

  quick(Parent, []) -> Parent ! {self(), []};
  quick(Parent, [H | T]) ->
      Pone = spawn_link(main, quick, [ self(), [ X || X <- T, H >= X ] ]) ,
      Ptwo = spawn_link(main, quick, [ self(), [ Y || Y <- T, H < Y ] ]) ,
      receive
          {Pone, Lone} ->
              receive
                  {Ptwo, Ltwo} -> Parent ! {self(), Lone ++ [H] ++ Ltwo}
              end;
          {Ptwo, Ltwo} ->
              receive
                  {Pone, Lone} -> Parent ! {self(), Lone ++ [H] ++ Ltwo}
              end
      end.

  sortquick(List) ->
      quick(self(), List).

稱為：

main:sortquick([12,4,7,22,25]).

Answer 1

代碼本身不是問題。 快速排序工作正常。 原因可能是你在子進程中獲得undef的原因是因為函數quick / 2根本沒有被導出。 當您使用模塊和函數調用spawn_link時，需要導出該函數。

您可以通過添加來修復此問題

-export([quick/2]).

或者通過將spawn_links更改為類似的東西

spawn_link(fun() -> quick(Self, [Y || Y <- T, H < Y]) end

雖然如果你采用后一種方式，你需要創建一個變量

Self = self()

在你打電話之前，否則它不會回到正確的過程。

Answer 2

上面的代碼通過導出quick / 2函數工作正常。

后來我比較了衍生的快速排序與未發送的快速排序的運行時間。 衍生的快速排序需要15秒到32秒之間的任何時間來排序范圍內的100萬個隨機數列表（1,1000000）。

未公開的快速排序是（代碼如下）：

 55 quicksort([]) -> [];
 56 quicksort([H]) -> [H];
 57 quicksort([H | T]) ->
 58     [Headnew | Tailnew] = [H | T],
 59     quicksort([ X || X <- Tailnew, Headnew >= X ]) ++ [Headnew] ++ quicksort([ Y || Y <- Tailnew, Headnew < Y ]).

需要5秒到8秒之間的任何時間來對100萬個隨機數的相同列表進行排序。

我在我的舊Thinkpad，1.7 Ghz處理器（單核）和512 Mb RAM上測試代碼。

產生快速排序的任何解釋都要比沒有出現的快速排序更差？

Answer 3

我對代碼稍作修改，以防止它產生許多進程。 當它在樹中達到某個級別時，它會切換到順序。

qsort([]) ->
    [];
qsort([H | T]) -> 
    qsort([ X || X <- T, X < H ]) ++ [H] ++ qsort([ X || X <- T, X >= H ]).

quick(Parent, [], _) -> Parent ! {self(), []};
quick(Parent, [H | T], C) when C > 0->
   Pone = spawn_link(test, quick, [ self(), [ X || X <- T, H >= X ], C-1 ]) ,
   Ptwo = spawn_link(test, quick, [ self(), [ Y || Y <- T, H < Y ], C-1 ]) ,
   receive
       {Pone, Lone} ->
              receive
                  {Ptwo, Ltwo} -> Parent ! {self(), Lone ++ [H] ++ Ltwo}
              end;
          {Ptwo, Ltwo} ->
              receive
                  {Pone, Lone} -> Parent ! {self(), Lone ++ [H] ++ Ltwo}
              end
      end;
quick(Parent, [H | T], _) -> 
    Parent ! {self(), qsort([ X || X <- T, X < H ]) ++ [H] ++ qsort([ X || X <- T, X >= H ])}.

sortquick(List) ->
    quick(self(), List, 4).