Bubble Sort in Ruby

Lately during my free time I’ve been reading through sorting algorithms for fun and decided to implement several in Ruby. I’ll be posting each one in a separate article as I go through them.

Here’s a bubble sort in Ruby.

Bubble sort is a pretty fun and easy sorting algorithm. For each pass through an array of values, each value is compared to its adjacent value and swapped into the correct order and so on. Worst case is O(n^2) and best case is O(n) if the array is already sorted.

Let’s start with the test.

require 'test/unit'
require "./bubble_sort.rb"

class SortingTests < Test::Unit::TestCase
  def test_bubble_sort
    @unsorted = (0..1000).to_a.sort{ rand() - 0.5 }[0..1000] # 1000 random integers in an array
    @sorted = @unsorted.sort
    bubble_sort = BubbleSort.new
    result = bubble_sort.sort(@unsorted)
    assert_equal @sorted, result

In the test I create an array of random numbers and assert_equal to the result of the bubble sort.

Next the code for the bubble sort.

class BubbleSort
  def sort(to_sort)
    # move the array to sort into a variable, which will be used for recursion
    arr_to_sort = to_sort
    # assume that we haven't swapped any values yet
    swapped = false
    # lower the length by one because we can't compare the last value since it's at the end
    length_of_sort = arr_to_sort.length - 1
    # begin loop through each value
    length_of_sort.times.each do |i|
      # if the value we're on is greater than the value to the left of it, swap
      if arr_to_sort[i] > arr_to_sort[i+1]
        # store values to be swapped
        a,b = arr_to_sort[i],arr_to_sort[i+1]
        # remove value we're on
        # insert the value to the right, moving the lesser value to the left
        arr_to_sort.insert(i+1, a)
        # swap is true since we did a swap during this pass
        swapped = true
    if swapped == false
      # no swaps, return sorted array
      return arr_to_sort
      # swaps were true, pass array to sort method
      bubble_sort = BubbleSort.new

I use recursion for each pass until swapped is equal to false, which means that the array is sorted.