Ruby sorting algorithms.

bubble_sort.rb

def bubble_sort(list)
  sorted = false
  until sorted
    sorted = true
    (0...list.length).each do |i|
      if !list[i + 1].nil? && list[i] > list[i + 1]
        list[i], list[i + 1] = list[i + 1], list[i]
        sorted = false
      end
    end
  end
  list
end

merge_sort.rb

def merge_sort(list)
  return list if list.length <= 1
  left  = list[0...list.length/2]
  right = list[list.length/2..-1]
  left  = merge_sort(left)
  right = merge_sort(right)
  merge(left, right)
end

def merge(left, right)
  result = []
  until left.empty? || right.empty?
    if left.first <= right.first
      result << left.shift
    else
      result << right.shift
    end
  end
  result += left  if right.empty?
  result += right if left.empty?
  result
end

quick_sort.rb

def quick_sort(list)
  return list if list.length <= 1
  pivot   = list.pop
  less    = []
  greater = []
  list.each do |i|
    less    << i if i <= pivot
    greater << i if i >  pivot
  end
  quick_sort(less) + [pivot] + quick_sort(greater)
end

radix_sort.rb

def radix_sort(list)
  passes = (list.max == 0) ? 1 : Math.log10(list.max).to_i + 1
  new_list = []
  passes.times do |i|
    buckets = make_buckets
    list.each do |n|
      digit = get_digit(n, i)
      buckets[digit] += [n]
    end
    new_list, buckets = buckets.flatten, make_buckets
  end
  new_list
end

def make_buckets
  Array.new(10,[])
end

def get_digit(n, i)
  n % (10 ** (i + 1)) / (10 ** i)
end