Add sort algorithms

Author: Romanow

README.md

@@ -0,0 +1,16 @@
+package ru.romanow.algorithms
+
+class BubbleSort {
+    fun sort(arr: IntArray) {
+        val n = arr.size
+        for (i in 0 until n - 1) {
+            for (j in 0 until n - i - 1) {
+                if (arr[j] > arr[j + 1]) {
+                    val temp = arr[j]
+                    arr[j] = arr[j + 1]
+                    arr[j + 1] = temp
+                }
+            }
+        }
+    }
+}

src/main/kotlin/ru/romanow/algorithms/BubbleSort.kt

@@ -0,0 +1,17 @@
+package ru.romanow.algorithms
+
+class InsertionSort {
+    fun sort(arr: IntArray) {
+        val n = arr.size
+        for (i in 1 until n) {
+            val key = arr[i]
+            var j = i - 1
+
+            while (j >= 0 && arr[j] > key) {
+                arr[j + 1] = arr[j]
+                j--
+            }
+            arr[j + 1] = key
+        }
+    }
+}

src/main/kotlin/ru/romanow/algorithms/InsertionSort.kt

@@ -0,0 +1,33 @@
+package ru.romanow.algorithms
+
+class MergeSort {
+    fun sort(arr: IntArray, left: Int = 0, right: Int = arr.size - 1) {
+        if (left < right) {
+            val middle = (left + right) / 2
+            sort(arr, left, middle)
+            sort(arr, middle + 1, right)
+            merge(arr, left, middle, right)
+        }
+    }
+
+    private fun merge(arr: IntArray, left: Int, middle: Int, right: Int) {
+        val leftArray = arr.sliceArray(left..middle)
+        val rightArray = arr.sliceArray(middle + 1..right)
+
+        var i = 0
+        var j = 0
+        var k = left
+
+        while (i < leftArray.size && j < rightArray.size) {
+            arr[k++] = if (leftArray[i] <= rightArray[j]) leftArray[i++] else rightArray[j++]
+        }
+
+        while (i < leftArray.size) {
+            arr[k++] = leftArray[i++]
+        }
+
+        while (j < rightArray.size) {
+            arr[k++] = rightArray[j++]
+        }
+    }
+}

src/main/kotlin/ru/romanow/algorithms/MergeSort.kt

@@ -0,0 +1,31 @@
+package ru.romanow.algorithms
+
+class QuickSort {
+    fun sort(arr: IntArray, low: Int = 0, high: Int = arr.size - 1) {
+        if (low < high) {
+            val pivotIndex = partition(arr, low, high)
+            sort(arr, low, pivotIndex - 1)
+            sort(arr, pivotIndex + 1, high)
+        }
+    }
+
+    private fun partition(arr: IntArray, low: Int, high: Int): Int {
+        val pivot = arr[high]
+        var i = low - 1
+
+        for (j in low until high) {
+            if (arr[j] <= pivot) {
+                i++
+                arr.swap(i, j)
+            }
+        }
+        arr.swap(i + 1, high)
+        return i + 1
+    }
+
+    private fun IntArray.swap(i: Int, j: Int) {
+        val temp = this[i]
+        this[i] = this[j]
+        this[j] = temp
+    }
+}

src/main/kotlin/ru/romanow/algorithms/QuickSort.kt

@@ -0,0 +1,44 @@
+package ru.romanow.algorithms
+
+import java.util.Stack
+
+class QuickSortWithoutRecursion {
+    fun sort(arr: IntArray) {
+        val stack = Stack<Pair<Int, Int>>()
+        stack.push(0 to arr.size - 1)
+
+        while (stack.isNotEmpty()) {
+            val (left, right) = stack.pop()
+
+            if (left < right) {
+                val pivotIndex = partition(arr, left, right)
+                if (pivotIndex - 1 > left) {
+                    stack.push(Pair(left, pivotIndex - 1))
+                }
+                if (pivotIndex + 1 < right) {
+                    stack.push(Pair(pivotIndex + 1, right))
+                }
+            }
+        }
+    }
+
+    private fun partition(arr: IntArray, low: Int, high: Int): Int {
+        val pivot = arr[high]
+        var i = low - 1
+
+        for (j in low until high) {
+            if (arr[j] <= pivot) {
+                i++
+                arr.swap(i, j)
+            }
+        }
+        arr.swap(i + 1, high)
+        return i + 1
+    }
+
+    private fun IntArray.swap(i: Int, j: Int) {
+        val temp = this[i]
+        this[i] = this[j]
+        this[j] = temp
+    }
+}

src/main/kotlin/ru/romanow/algorithms/QuickSortWithoutRecursion.kt

@@ -0,0 +1,20 @@
+package ru.romanow.algorithms
+
+class SelectionSort {
+    fun sort(arr: IntArray) {
+        val n = arr.size
+        for (i in 0 until n - 1) {
+            var idx = i
+            for (j in i + 1 until n) {
+                if (arr[j] < arr[idx]) {
+                    idx = j
+                }
+            }
+            if (idx != i) {
+                val temp = arr[i]
+                arr[i] = arr[idx]
+                arr[idx] = temp
+            }
+        }
+    }
+}

src/main/kotlin/ru/romanow/algorithms/SelectionSort.kt

@@ -1,4 +1,4 @@
-package ru.romanow
+package ru.romanow.easy
 
 /**
  * Вы являетесь менеджером по продукту, и в настоящее время возглавляете

…ain/kotlin/ru/romanow/FirstBadVersion.kt …otlin/ru/romanow/easy/FirstBadVersion.ktsrc/main/kotlin/ru/romanow/FirstBadVersion.kt renamed to src/main/kotlin/ru/romanow/easy/FirstBadVersion.kt src/main/kotlin/ru/romanow/FirstBadVersion.kt renamed to src/main/kotlin/ru/romanow/easy/FirstBadVersion.kt

@@ -1,4 +1,4 @@
-package ru.romanow
+package ru.romanow.easy
 
 /**
  * Даны две строки, `needle` и `haystack`, верните индекс первого

…n/ru/romanow/FirstOccurrenceInAString.kt …romanow/easy/FirstOccurrenceInAString.ktsrc/main/kotlin/ru/romanow/FirstOccurrenceInAString.kt renamed to src/main/kotlin/ru/romanow/easy/FirstOccurrenceInAString.kt src/main/kotlin/ru/romanow/FirstOccurrenceInAString.kt renamed to src/main/kotlin/ru/romanow/easy/FirstOccurrenceInAString.kt

@@ -1,4 +1,4 @@
-package ru.romanow
+package ru.romanow.easy
 
 /**
  * Реализовать функцию, которая принимает целочисленное число без знака