Modify quick sort to use immutable swap

Author: ashwinbhaskar

scala-way/src/main/scala/divideandconquer/QuickSort.scala

@@ -1,6 +1,7 @@
 package divideandconquer
 
 import scala.annotation.tailrec
+import util.Utility.swap
 
 /*
 An implementation of the quick sort algorithm
@@ -12,34 +13,32 @@ object QuickSort extends App{
 
   println(quickSort(arrayToSort).mkString(" "))
 
-  def quickSort(inputArray : Array[Int]) : Array[Int] = inputArray match {
-    case Array() => inputArray    //empty array
-    case Array(_) => inputArray   //single element array
-    case _ =>                     //else
-    val initialPivotPos = inputArray.length/2
-    val finalPivotPos = giveFinalPivotPosAndModifyArray(initialPivotPos,inputArray)
-    quickSort(inputArray.take(finalPivotPos)) ++ Array(inputArray{finalPivotPos}) ++ quickSort(inputArray.drop(finalPivotPos+1))
+  def quickSort(arr: Array[Int]): Array[Int] = arr match {
+    case Array() | Array(_) => arr
+    case _ =>
+      val pivotPos = arr.length/2
+      val (newArray, finalPivotPos) = movePivotToCorrectPos(arr, pivotPos)
+      quickSort(newArray.take(finalPivotPos)) ++ Array(newArray(finalPivotPos)) ++ quickSort(newArray.drop(finalPivotPos + 1))
   }
 
-  def swap(pos1 : Int, pos2 : Int)(array : Array[Int]) : Unit = {
-    val temp = array{pos1}
-    array{pos1} = array{pos2}
-    array{pos2} = temp
-  }
-
-  def giveFinalPivotPosAndModifyArray(initialPivotPos : Int,array : Array[Int]) : Int = {
+  def movePivotToCorrectPos(array: Array[Int], pivotPos: Int): (Array[Int], Int) = {
+    val pivot = array(pivotPos)
+    val lowIndex = 1
+    val highIndex = array.length - 1
 
     @tailrec
-    def internalFunc(headPos : Int, tailPos : Int): Int = if(headPos > tailPos) tailPos
-    else if(array{headPos} > array{0}){
-      swap(headPos,tailPos)(array)
-      internalFunc(headPos,tailPos-1)
-    } else internalFunc(headPos+1, tailPos)
-
-    swap(0,initialPivotPos)(array)
-    val finalPivotPos = internalFunc(1,array.length-1)
-    swap(0,finalPivotPos)(array)
-    finalPivotPos
+    def recur(arr: Array[Int], lI: Int, hI: Int): (Array[Int], Int) =
+      if(lI > hI) (arr, hI)
+      else if (arr(lI) > pivot) {
+        val newArray = swap(arr, lI, hI)
+        recur(newArray, lI, hI - 1)
+      } else {
+        recur(arr, lI + 1, hI)
+      }
+
+    val mTemp = swap(array, 0, pivotPos)                   //move pivot to 0 index
+    val (newArray, correctPivotPos) = recur(mTemp, lowIndex, highIndex)
+    val finalArray = swap(newArray, 0, correctPivotPos)    //move pivot to correct pos
+    (finalArray, correctPivotPos)
   }
-
 }