Ruby and Swift merge sort implementation

Merge_Sort/Ruby/TarangKhanna/merge_sort.rb

@@ -0,0 +1,41 @@
+=begin
+This method has a big O of O(nlog2n). It uses a divide and conquer startegy.
+Conceptually, a merge sort works as follows:
+
+Divide the unsorted list into n sublists, each containing 1 element (a list of 1 element is considered sorted).
+Repeatedly merge sublists to produce new sorted sublists until there is only 1 sublist remaining. This will be the sorted list.
+Source: https://en.wikipedia.org/?title=Merge_sort
+=end
+
+def mergesort(array)
+  def merge(left_sorted, right_sorted)
+    res = []
+    l = 0
+    r = 0
+
+    loop do
+      break if r >= right_sorted.length and l >= left_sorted.length
+
+      if r >= right_sorted.length or (l < left_sorted.length and left_sorted[l] < right_sorted[r])
+        res << left_sorted[l]
+        l += 1
+      else
+        res << right_sorted[r]
+        r += 1
+      end
+    end
+
+    return res
+  end
+
+  def mergesort_iter(array_sliced)
+    return array_sliced if array_sliced.length <= 1
+
+    mid = array_sliced.length/2 - 1
+    left_sorted = mergesort_iter(array_sliced[0..mid])
+    right_sorted = mergesort_iter(array_sliced[mid+1..-1])
+    return merge(left_sorted, right_sorted)
+  end
+
+  mergesort_iter(array)
+end

Merge_Sort/Ruby/TarangKhanna/merge_sort_test.rb

@@ -0,0 +1,7 @@
+require './merge_sort'
+
+describe "#merge_sort" do
+  it "Sort The Array" do
+    merge_sort([5,3,6,2,4]).should eq([2,3,3,5,6])
+  end
+end

Merge_Sort/Swift/TarangKhanna/merge_sort.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+// Build 100 random numbers between 0 and 100
+var numbers = Int[]()
+for i in 1..100 {
+    let n = Int(arc4random() % 101)
+    numbers.append(n)
+}
+
+func elementsInRange<T>(a: T[], start: Int, end: Int) -> (T[]) {
+    var result = T[]()
+
+    for x in start..end {
+        result.append(a[x])
+    }
+
+    return result
+}
+
+func merge<T: Comparable>(a: T[], b: T[], mergeInto acc: T[]) -> T[] {
+    if a == [] {
+        return acc + b
+    } else if b == [] {
+        return acc + a
+    }
+
+    if a[0] < b[0] {
+        return merge(elementsInRange(a, 1, a.count), b, mergeInto: acc + [a[0]])
+    } else {
+        return merge(a, elementsInRange(b, 1, b.count), mergeInto: acc + [b[0]])
+    }
+}
+
+func mergesort<T: Comparable>(a: T[]) -> T[] {
+    if a.count <= 1 {
+        return a
+    } else {
+        let firstHalf = elementsInRange(a, 0, a.count/2)
+        let secondHalf = elementsInRange(a, a.count/2, a.count)
+
+        return merge(mergesort(firstHalf), mergesort(secondHalf), mergeInto: [])
+    }
+}
+
+let sorted = mergesort(numbers)
+
+println(sorted)

Merge_Sort/Swift/TarangKhanna/merge_sort_test.swift

@@ -0,0 +1,37 @@
+//
+//  merge_sort_test.swift
+//  
+//
+//  Created by Tarang khanna on 7/29/15.
+//
+//
+
+import Foundation
+
+func testBubbleSort() { // swift 1.2 compatible
+
+    let numberList : Array<Int> = [4, 3, 23, 2, 14, 41, 15,12]
+    var mergeSortTest: merge_sort = merge_sort()
+
+    // pass the list to be sorted
+    var resultList: Array<Int>! = mergeSortTest.mergesort(numberList)
+
+    // determine if the numbers are sorted
+    var x: Int = 0
+    for (x = 0; x < resultList.count; x++) {
+
+        if ((x > 0) && (resultList[x] < resultList[x - 1])) {
+            XCTFail("numberlist items not in sorted order")
+        }
+        else {
+            println("item \(resultList[x]) is sorted")
+        }
+
+
+    } // end for
+
+
+
+} // end function
+
+// supports all datatypes using generics