Bubble sort in Ruby

Question

For practice, I tried implementing Bubble sort in Ruby. I wasn't very sure how nested for loops would look like in Ruby. Is this the 'right way' to do this in Ruby? I found this question, but it looks much more complicated with stacks.

def bubble_sort(list)
  n = list.length
  n.downto(2) do |i|
    0.upto(i-2) do |j|
      if list[j] > list[j+1]
        list[j],list[j+1] = list[j+1],list[j]
      end
    end
  end
  puts list
end

This is the code I wrote in Python which I then translated into Ruby code above.

def bubbleSort(alist):
    n = len(alist)
    for i in range(n, 1, -1):
        for j in range(i-1):
            if alist[j] > alist[j+1] :
                alist[j],alist[j+1] = alist[j+1],alist[j]

Answer 1

A significant difference between your Python and Ruby implementations is that the Ruby one prints the sorted list at the end. It shouldn't, just like the Python version doesn't. The function should do just one thing, in this example just sort.

Also, I suggest to putting a space after commas separating variable lists, like this:

    list[j], list[j+1] = list[j+1], list[j]

I don't know much Ruby, but I don't think a bubble sort can get any better than this. You are using nice Ruby-like idiomatic expressions like downto and upto, and the rest is clear, straight code. Anything more clever than this would be too clever for the purpose, in my opinion.

A tiny final remark about the Python implementation: snake_case is recommended for function names instead of camelCase.

Answer 2

I loved the question, but didn't think to answer it until just a bit before I went to bed...

...So here are my two takes on the bubble sort code, including testing code.

I'll update the answer with more info after I slept a bit, but it should be quite straight forward.

I iterate the array using a numerical index until there is nothing to sort, at which point I break from the iterations. In one version I use the sorted variable, while in the next I use a temporary array (allowing me to make it a one-line implementation).

a = Array.new(100) {Random.rand 1000}


def bubble_sort!(array)
    sorted = false
    until sorted
        sorted = true
        (array.length-1).times { |i|  (sorted, array[i], array[i+1] = false, array[i+1], array[i]) if array[i] > array[i+1] }
    end 
end


def bubble_sort!(array)
    break if ((array.length-1).times.with_object([]) { |i, r| (r << (array[i], array[i+1] = array[i+1], array[i])) if array[i] > array[i+1] }).empty? while true
end


#testing

def array_sorted?(array)
    r = (array.length-1).times.with_object([]) { |i, r| (array[i] > array[i+1]) ? (r << "failed at #{i}!!!"): true}
    puts (r.empty? ? "Yes!" : "No :-(") 
end

array_sorted? a
bubble_sort! a
array_sorted? a

Good luck!