sort_samples.ex

defmodule MergeSort do                                                          
  def sort([]), do: []                                                          
  def sort([h | []]), do: [h]                                                   
  def sort(l) do                                                                
    {l1, l2} = Enum.split(l, div(length(l), 2))                                 
    merge(l1, l2)                                                               
  end                                                                           
  def merge([h1 | []], [h2 | []]) do                                            
    if h1 > h2 do                                                               
      :lists.merge([h2], [h1])                                                  
    else                                                                        
      :lists.merge([h1], [h2])                                                  
    end                                                                         
  end                                                                           
  def merge(l1, l2) do                                                          
    :lists.merge(sort(l1), sort(l2))                                            
  end                                                                           
end                                                                             
                                                                                
defmodule QuickSort do                                                          
  def sort([]), do: []                                                          
  def sort(l) do                                                                
    [head | tail] = l                                                              
    {l1, l2} = partition(head, tail)                                               
    sort(l1) ++ [head] ++ sort(l2)                                                 
  end                                                                              
  def partition(pivot, rest) do                                                    
    lesser = Enum.filter(rest, &(&1 < pivot))                                      
    greater = Enum.filter(rest, &(&1 >= pivot))                                    
                                                                                   
    {lesser, greater}                                                              
  end                                                                              
end                                                                                
                                                                                   
# Elixir version of Erlang Joe Armstrong version found in Programming Erlang book.
defmodule QuickSort_JA do                                                          
  def sort([]), do: []                                                             
  def sort([pivot|t]) do                                                           
    sort(for x <- t, x < pivot, do: x)                                             
    ++ [pivot] ++                                                                  
    sort(for x <- t, x >= pivot, do: x)                                            
  end                                                                              
end                                                                                
                                                                                   
list = 1..30000 |> Enum.map(fn _ -> Enum.random(1..100) end)                       
                                                                                   
{t1, _ }  = :timer.tc(QuickSort, :sort, [list])                                    
IO.puts "QuickSort: #{t1}"                                                         
                                                                                   
{t2, _ }  = :timer.tc(QuickSort_JA, :sort, [list])                                 
IO.puts "JA QuickSort: #{t2}"                                                      
                                                                                   
{t3, _ }  = :timer.tc(MergeSort, :sort, [list])                                    
IO.puts "MergeSort: #{t3}"