sortech 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8a69ef2c9c0bc4a5ba3fc0c1e6370bf5117b0a7
-  data.tar.gz: 016362b6decef9da9729e6d5fa6ecbb596b09c4a
+  metadata.gz: 84f353b9ca32d5c35de10c3a62ed8fc78f1e59dc
+  data.tar.gz: 7fb34164abd1a2b3ea61ef83cc79a21a48ffeaf4
 SHA512:
-  metadata.gz: 52107a459920ed628254a2d894a5bfb92a04cc31de3ee24f5b887007816ba11af2a581c23977e943a2ef1cd18d933463335b478572d5e5382617e5379c347f74
-  data.tar.gz: 31f2fe51f89eeda809229dfe734edfb3ecba5c8b589823e733c92db66c07bc1ccbd148bfdd431fa6c2d21889b910e5d63644f972959295fc680f67768c445283
+  metadata.gz: 884c0c43fffa371dfaa897cec669e99f008c0c135619c38a0178cd13c055b176c0020544ed3865c3dac8f1bbd63bc66a7470cbb39c8ad2aac569a31003b87c1e
+  data.tar.gz: 223440b4e3099053449e9860e63f3cb20fb3def3213b0c7cd8293600d45a17374fc80fb2f0b30b88942ad48f4ce402a134126ad173cf9ac849e09a2f809858d1

data/lib/sortech.rb

@@ -1,6 +1,16 @@
 module Sortech
   class Sort
     class << self
+      # Sort an array using Bubble sort technique
+      # Advantages:
+      #     1. Straightforward, simple and slow.
+      #     2. Stable.
+      #     3. Inefficient on large tables.
+      #
+      # @param [Array<Integer>]
+      #
+      # @return Array
+      #
       def bubble(arr)
         arr if arr.length == 0 || is_sorted?(arr)
         n = arr.length
@@ -8,9 +18,7 @@ module Sortech
           flag = false
           for i in 0..n - 2
             if arr[i] > arr[i+1]
-              arr[i] += arr[i+1]
-              arr[i+1] = arr[i] - arr[i+1]
-              arr[i] = arr[i] - arr[i+1]
+              arr[i], arr[i+1] = arr[i+1], arr[i]
               flag = true
             end
           end
@@ -20,15 +28,198 @@ module Sortech
         arr
       end
 
-      private
-        def is_sorted? arr
-          for i in 0..arr.length - 2
-            if arr[i] > arr[i+1]
-              return false
+      # Sort an array using Selection sort technique
+      # Advantages:
+      #     1. Improves the performance of bubble sort and also slow.
+      #     2. Unstable but can be implemented as a stable sort.
+      #     3. Quite slow for large amount of data.
+      #
+      # @param [Array<Integer>]
+      #
+      # @return Array
+      #
+      def selection(arr)
+        arr if arr.length == 0 || is_sorted?(arr)
+        n = arr.length
+        for i in 0..n - 1
+          s = arr[i]
+          p = i
+          for j in i+1..n - 1
+            if s > arr[j]
+              s = arr[j]
+              p = j
             end
           end
-          true
+          arr[i], arr[p] = arr[p], arr[i]
+        end
+        arr
+      end
+
+      # Sort an array using Insertion sort technique
+      #
+      # Advantages:
+      #     1. Efficient for small list and mostly sorted list.
+      #     2. Sort big array slowly.
+      #     3. Save memory
+      #
+      # @param [Array<Integer>]
+      #
+      # @return Array
+      #
+      def insertion(arr)
+        for i in 1..arr.length - 1
+          t = arr[i]
+          j = i - 1
+          while j >= 0 && arr[j] > t
+            arr[j+1] = arr[j]
+            j -= 1
+          end
+          arr[j+1] = t
+        end
+        arr
+      end
+
+      # Sort an array using Quick sort technique
+      # Advantages:
+      #   1. Fastest sorting algorithm in practice.
+      #   2. Available in many standard libraries.
+      #   3. O (log n) space usage.
+      #   4. Unstable sort and complex for choosing a good pivot element.      # @param [Array<Integer>]
+      #
+      # @param [Array<Integer>]
+      #
+      # @return Array
+      #
+      def quicksort(arr, low=0, high=arr.length-1)
+
+        if low < high
+          pi = partition(arr, low, high)
+          quicksort(arr, low, pi-1) # called before pi
+          quicksort(arr, pi+1, high) # called after pi
+        end
+        arr
+      end
+
+      # Sort an array using Merge sort technique
+      # Advantages:
+      #   1.  Well for very large list, stable sort.
+      #   2. A fast recursive sorting.
+      #   3. Both useful for internal and external sorting.
+      #   4. It requires an auxiliary array that is as large as the original array to be sorted.
+      #
+      # @param [Array<Integer>]
+      #
+      # @return Array
+      #
+      def mergesort(arr, left=0,right=arr.length-1)
+
+        if left < right
+          middle = (left + (right - 1))/2
+
+          mergesort(arr,left,middle) # sort first half
+          mergesort(arr, middle+1,right) # sort second half
+          merge(arr, left, middle, right) # merge the two arrays
         end
-    end
-  end
-end
+        arr
+      end
+
+      # Sort an array using Radix sort technique
+      # Advantages:
+      #     1. Stable, fast.
+      #     2. Used in special cases when the key can be
+      #
+      # @param [Array<Integer>]
+      #
+      # @return Array
+      # TODO: Implement
+      def radix(arr)
+      end
+
+      private
+      # Returns true or false depending on whether array is sorted or not
+      #
+      # @param [Array<Integer>]
+      #
+      # @return Boolean
+      #
+      def is_sorted? arr
+        return false if arr.nil?
+        for i in 0..(arr.length - 2)
+          if arr[i] > arr[i+1]
+            return false
+          end
+        end
+        true
+      end
+
+      def partition arr, low, high
+        pivot = arr[high]
+        i = low - 1
+        for j in low..high-1
+          if arr[j] <= pivot
+            i += 1
+            arr[i], arr[j] = arr[j], arr[i]
+          end
+        end
+        arr[i+1], arr[high] = arr[high], arr[i+1]
+        i+1
+      end # partition
+
+      # Splits the array into two halves and merge them in sorted order
+      # back to the original array
+      #
+      # @param [Array<Integer>, Integer, Integer, Integer]
+      #
+      # @return Boolean
+      #
+
+      def merge arr, left, middle, right
+        n1 = middle - left + 1
+        n2 = right - middle
+
+        # Create empty arrays of size n1 and n2
+        left_array = Array.new(n1){0}
+        right_array = Array.new(n1){0}
+
+        # copy data to empty arrays
+        for i in 0..n1
+          left_array[i] = arr[left+i]
+        end
+        for i in 0..n2
+          right_array[i] = arr[middle + i + 1]
+        end
+
+        # Merge two arrays back into arr
+        i = 0
+        j = 0
+        k = left
+
+        while i < n1 && j < n2
+          if left_array[i] <= right_array[j]
+            arr[k] = left_array[i]
+            i += 1
+          else
+            arr[k] = right_array[j]
+            j += 1
+          end
+          k += 1
+        end
+
+        # copy the remaining elements of left_array, if any
+        while i < n1
+          arr[k] = left_array[i]
+          i += 1
+          k += 1
+        end
+
+        # copy the remaining elements of right_array, if any
+        while j < n2
+          arr[k] = right_array[j]
+          j += 1
+          k += 1
+        end
+      end # merge
+
+    end # Class self
+  end # Sort
+end # Sortech

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sortech
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Mansoor Khan