Little Help implementing Quick-sort algorithm

You sort only less_than_head (BTW Your head is commonly called pivot) and greater_than_head is passed as is, so there is only partial sorting (only elements less than head are sorted).

EDIT: The big pro of using :lists.partition/2 is that it will split your list into two in one “walk” through the list instead of two, which can be improvement in case of long lists (but in such case the quick sort isn’t the best solution anyway, merge sort will work better).

So your 2 comprehensions can be easily replaced with:

{lesser, greater} = :lists.partition(& &1 <= head, tail)

Got deprecated warning with Enum.partition/2,
Enum.split_with/2 instead.
Works great!
Thanks

My mistake :lists.partition/2 still works
updated to this

defmodule Quick do
  import Enum, only: [split_with: 2]
  def sort([]), do: []
  def sort([head|tail]) do
    {pivot, greater_than_head} = split_with(tail, &(&1 <= head))
    sort(pivot) ++ [head] ++ (greater_than_head)
   end

end

big thanks @hauleth

Thanks to you,
Will replace the list comprehension with Enum.partition

Not the lesser_than_head is usually called pivot, but the head is. Its the pivot point you use to compare.

Also you are still not sorting the greater_than_head

This should be written as:

def sort([]), do: []
def sort([pivot | tail]) do
  {lesser, greater} = Enum.split_by(tail, & &1 <= pivot)

  sort(lesser) ++ [pivot] ++ sort(greater)
end

As you still do not sort greater part as @NobbZ said.

Ohh,
It has been written well in the Idea, didn’t know I failed to include sort greater.
Thanks to you