Adding algorithm that lets you find both the minimum and maximum at the same time but doing only 3 comparisons for every 2 items

Author: Chris Pilcher

Select Minimum Maximum/MinimumMaximumPairs.swift

@@ -0,0 +1,32 @@
+func minimumMaximum<T: Comparable>(var array: [T]) -> (minimum: T, maximum: T)
+{
+  var minimum = array.first!
+  var maximum = array.first!
+
+  let hasOddNumberOfItems = array.count % 2 != 0
+  if hasOddNumberOfItems {
+    array.removeFirst()
+  }
+
+  while !array.isEmpty {
+    let pair = (array.removeFirst(), array.removeFirst())
+
+    if pair.0 > pair.1 {
+      if pair.0 > maximum {
+        maximum = pair.0
+      }
+      if pair.1 < minimum {
+        minimum = pair.1
+      }
+    } else {
+      if pair.1 > maximum {
+        maximum = pair.1
+      }
+      if pair.0 < minimum {
+        minimum = pair.0
+      }
+    }
+  }
+
+  return (minimum, maximum)
+}

Select Minimum Maximum/README.markdown

@@ -4,7 +4,9 @@ Goal: Find the minimum/maximum object in an unsorted array.
 
 We have an array of generic objects and we iterate over all the objects keeping track of the minimum/maximum element so far.
 
-### An example
+### Maximum or minimum
+
+#### An example
 
 Let's say the we want to find the maximum value in the unsorted list `[ 8, 3, 9, 4, 6 ]`.
 
@@ -14,9 +16,9 @@ Pick the next number from the list, `3`, and compare it to the current maximum `
 
 Pick the next number from the list, `9`, and compare it to the current maximum `8`. `9` is greater than `8` so we store `9` as the maximum.
 
-Repeat this process until the all items in the list have been processed.
+Repeat this process until the all elements in the list have been processed.
 
-### The code
+#### The code
 
 Here is a simple implementation in Swift:
 
@@ -46,9 +48,59 @@ minimum(array) // This will return 3
 maximum(array) // This will return 9
 ```
 
+### Maximum and minimum
+
+To find both the maximum and minimum values contained in array while minimizing the number of comparisons we can compare the items in pairs. 
+
+```swift
+func minimumMaximum<T: Comparable>(var array: [T]) -> (minimum: T, maximum: T)
+{
+  var minimum = array.first!
+  var maximum = array.first!
+
+  let hasOddNumberOfItems = array.count % 2 != 0
+  if hasOddNumberOfItems {
+    array.removeFirst()
+  }
+
+  while !array.isEmpty {
+    let pair = (array.removeFirst(), array.removeFirst())
+
+    if pair.0 > pair.1 {
+      if pair.0 > maximum {
+        maximum = pair.0
+      }
+      if pair.1 < minimum {
+        minimum = pair.1
+      }
+    } else {
+      if pair.1 > maximum {
+        maximum = pair.1
+      }
+      if pair.0 < minimum {
+        minimum = pair.0
+      }
+    }
+  }
+
+  return (minimum, maximum)
+}
+```
+
+Put this code in a playground and test it like so:
+
+```swift
+
+let result = minimumMaximum(array)
+result.minimum // This will return 3
+result.maximum // This will return 9
+```
+
+By picking elements in pairs and comparing their maximum and minimum with the running minimum and maximum we reduce the number of comparisons to 3 for every 2 elements.
+
 ### Performance
 
-The algorithm runs at **O(n)**. It compares each object in the array with the running minimum/maximum so the time it takes is proportional to the array length.
+These algorithms run at **O(n)**. Each object in the array is compared with the running minimum/maximum so the time it takes is proportional to the array length.
 
 ### Swift library
 

Select Minimum Maximum/SelectMinimumMaximum.playground/Contents.swift

@@ -1,3 +1,4 @@
+// Compare each item to find minimum
 func minimum<T: Comparable>(var array: [T]) -> T? {
   var minimum = array.removeFirst()
   for element in array {
@@ -6,6 +7,7 @@ func minimum<T: Comparable>(var array: [T]) -> T? {
   return minimum
 }
 
+// Compare each item to find maximum
 func maximum<T: Comparable>(var array: [T]) -> T? {
   var maximum = array.removeFirst()
   for element in array {
@@ -14,11 +16,50 @@ func maximum<T: Comparable>(var array: [T]) -> T? {
   return maximum
 }
 
-// Simple test of minimum and maximum functions
+// Compare in pairs to find minimum and maximum
+func minimumMaximum<T: Comparable>(var array: [T]) -> (minimum: T, maximum: T)
+{
+  var minimum = array.first!
+  var maximum = array.first!
+
+  let hasOddNumberOfItems = array.count % 2 != 0
+  if hasOddNumberOfItems {
+    array.removeFirst()
+  }
+
+  while !array.isEmpty {
+    let pair = (array.removeFirst(), array.removeFirst())
+
+    if pair.0 > pair.1 {
+      if pair.0 > maximum {
+        maximum = pair.0
+      }
+      if pair.1 < minimum {
+        minimum = pair.1
+      }
+    } else {
+      if pair.1 > maximum {
+        maximum = pair.1
+      }
+      if pair.0 < minimum {
+        minimum = pair.0
+      }
+    }
+  }
+
+  return (minimum, maximum)
+}
+
+// Test of minimum and maximum functions
 let array = [ 8, 3, 9, 4, 6 ]
 minimum(array)
 maximum(array)
 
+// Test of minimumMaximum function
+let result = minimumMaximum(array)
+result.minimum
+result.maximum
+
 // Built-in Swift functions
 array.minElement()
 array.maxElement()