added Shellsort

Author: Morfly

src/kotlin/sequential/math/3SmoothNumbers.kt

@@ -0,0 +1,67 @@
+package sequential.math
+
+import kotlin.math.ln
+import kotlin.math.min
+import kotlin.math.round
+
+
+/**
+ * Calculates number of 3-smooth numbers till [N].
+ *
+ * An alternative formula is also applicable:
+ * (ln(N) / ln(2.0) + 1) * (ln(N) / ln(3.0) + 1) * 0.5
+ *
+ * Note: the result of the function is approximate and may differ from the correct one by +-1 (or +-2 in rear cases).
+ *
+ * @see [Ramanujan's First Letter to Hardy and the Number of 3-Smooth Integers](https://math.stackexchange.com/questions/15966/ramanujans-first-letter-to-hardy-and-the-number-of-3-smooth-integers)
+ * @see [3-Smooth Representations of Integers](https://www.jstor.org/stable/2589404)
+ */
+fun count3SmoothNumbers(N: Int) =
+        (ln(2.0 * N) * ln(3.0 * N)) / (2 * ln(2.0) * ln(3.0))
+
+
+fun list3SmoothNumbers(N: Int): IntArray {
+    if (N <= 0) return IntArray(size = 0)
+
+    val sequenceSize = round(count3SmoothNumbers(N)).toInt() + 1
+
+    var numbers = IntArray(sequenceSize)
+    numbers[0] = 1
+    var i2 = 0
+    var i3 = 0
+    var i = 1
+
+    var n2: Int
+    var n3: Int
+    var number: Int
+    while (true) {
+        n2 = 2 * numbers[i2]
+        n3 = 3 * numbers[i3]
+        number = min(n2, n3)
+
+        if (number >= N) break
+        numbers[i++] = number
+
+        if (n2 <= n3) i2++
+        if (n2 >= n3) i3++
+    }
+
+    if (numbers.last() == 0) numbers = numbers.removeTrailingZeros()
+
+    return numbers
+}
+
+
+/**
+ * Utility function that removes trailing zeros from the gap sequence array.
+ *
+ * @return copy of the original array without trailing zeros.
+ */
+private fun IntArray.removeTrailingZeros(): IntArray {
+    if (last() != 0) return this
+
+    var zeroId = lastIndex
+    while (this[lastIndex - 1] == 0) zeroId--
+
+    return copyOfRange(0, zeroId)
+}

src/kotlin/sequential/math/BUILD

@@ -0,0 +1,4 @@
+exports_files(
+    ["3SmoothNumbers.kt"],
+    visibility = ["//:__subpackages__"]
+)

src/kotlin/sequential/sorting/insertionsort/RangedInsertionSort.kt

@@ -1,4 +1,4 @@
-package sequential.sorting.insertionsort
+package sequential.sorting.insertionsort.ranged
 
 import _util.*
 

src/kotlin/sequential/sorting/quicksort/FunctionalQuickSort.kt

@@ -1,4 +1,4 @@
-package sequential.sorting.quicksort
+package sequential.sorting.quicksort.functional
 
 import _util.*
 

src/kotlin/sequential/sorting/quicksort/QuickSort.kt

@@ -1,9 +1,12 @@
 package sequential.sorting.quicksort
 
-import sequential.sorting.insertionsort.insertionSort
-import sequential.sorting.quicksort.partition.lomutoPartition
+import _util.isSorted
+import _util.print
+import _util.randomIntArray
+import _util.shuffle
+import sequential.sorting.insertionsort.ranged.insertionSort
 import sequential.sorting.quicksort.partition.hoarePartition
-import _util.*
+import sequential.sorting.quicksort.partition.lomutoPartition
 
 
 /**

src/kotlin/sequential/sorting/selectionsort/SelectionSort.kt

@@ -0,0 +1,28 @@
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+kt_jvm_library(
+    name = "shellsort_lib",
+    srcs = glob([
+        "*.kt",
+        "gapsequence/*.kt",
+        "_measurement/MeasuredShellSort.kt"
+    ]) + [
+        "//sequential/math:3SmoothNumbers.kt"
+    ],
+    deps = [
+        "//sequential/sorting/_measurement:measurement",
+        "//:utils",
+    ]
+)
+
+java_binary(
+    name = "shellsort",
+    main_class = "sequential.sorting.shellsort.ShellSortKt",
+    runtime_deps = [":shellsort_lib"],
+)
+
+java_binary(
+    name = "shellsort_measured",
+    main_class = "sequential.sorting.shellsort._measurement.MeasuredShellSortKt",
+    runtime_deps = [":shellsort_lib"],
+)

src/kotlin/sequential/sorting/shellsort/BUILD

@@ -0,0 +1,2 @@
+# Shellsort
+...

src/kotlin/sequential/sorting/shellsort/README.md

@@ -0,0 +1,42 @@
+package sequential.sorting.shellsort
+
+import _util.isSorted
+import _util.print
+import _util.randomIntArray
+import sequential.sorting.shellsort.gapsequence.ShellGapSequence
+
+
+/**
+ * Sorts given array using Shellsort.
+ */
+fun IntArray.shellSort() {
+    shellSort(ShellGapSequence.compute(size))
+}
+
+/**
+ * Sorts given array with Shellsort using provided gap sequence.
+ */
+fun IntArray.shellSort(gaps: IntArray) {
+    for (gap in gaps) {
+        for (i in gap..lastIndex) {
+            var j = i
+            val arri = this[i]
+            while (j >= gap && arri < this[j - gap]) {
+                this[j] = this[j - gap]
+                j -= gap
+            }
+            this[j] = arri
+        }
+    }
+}
+
+
+fun main() {
+    val array = randomIntArray(size = 20)
+    array.print()
+
+    array.shellSort()
+
+    println("Sorting is successful: ${array.isSorted()}")
+    array.print()
+}

src/kotlin/sequential/sorting/shellsort/ShellSort.kt

@@ -0,0 +1,39 @@
+package sequential.sorting.shellsort._measurement
+
+import _util.isSorted
+import _util.print
+import _util.randomIntArray
+import sequential.sorting._measurement.measured
+import sequential.sorting.shellsort.gapsequence.ShellGapSequence
+
+
+/**
+ * Sorts given array with Shellsort using provided gap sequence.
+ */
+fun IntArray.shellSort(gaps: IntArray) = measured {
+    for (gap in gaps) {
+        for (i in gap..lastIndex) {
+            var j = i
+            val arri = this[i]
+            while (j >= gap && arri < this[j - gap]) {
+                this[j] = this[j - gap]
+                j -= gap
+            }
+            this[j] = arri
+        }
+    }
+}
+
+
+fun main() {
+    val array = randomIntArray(size = 20)
+    array.print()
+
+    val gapSequence = ShellGapSequence.compute(array.size)
+    val measurement = array.shellSort(gapSequence)
+
+    println("Sorting is successful: ${array.isSorted()}")
+    array.print()
+
+    println("$measurement")
+}

src/kotlin/sequential/sorting/shellsort/_measurement/MeasuredShellSort.kt

@@ -0,0 +1,52 @@
+package sequential.sorting.shellsort.gapsequence
+
+import kotlin.math.ceil
+import kotlin.math.pow
+
+
+/**
+ * @see [Shellsort, 2.48^(k-1) vs Tokuda's sequence](https://stackoverflow.com/questions/21508595/shellsort-2-48k-1-vs-tokudas-sequence)
+ * @see TokudaGapSequence
+ */
+object GapSequence248 {
+
+    /**
+     * Precomputed gap sequence for arrays of integer range.
+     */
+    val get = intArrayOf(
+            1181377402, 476361856, 192081394, 77452175, 31230716, 12593031, 5077835, 2047515,
+            825611, 332908, 134237, 54128, 21826, 8801, 3549, 1431, 577, 233, 94, 38, 16, 7, 3, 1
+    )
+
+    /**
+     * Computes gap sequence for the given array size.
+     */
+    fun compute(arraySize: Int): IntArray {
+        if (arraySize <= 1) return intArrayOf(1)
+
+        var k = 1
+        var gap = 1
+        while (gap < arraySize) {
+            gap = computeTerm(k + 1)
+            k++
+        }
+
+        val gaps = IntArray(--k)
+        for (i in 0..gaps.lastIndex) {
+            gaps[i] = computeTerm(k--)
+        }
+
+        return gaps
+    }
+
+    /**
+     * General term of the gap sequence.
+     *
+     * @param k sequence term number (starting from 1).
+     * @return k-th term of the sequence.
+     */
+    private fun computeTerm(k: Int) =
+            ceil(
+                    2.48.pow(k - 1)
+            ).toInt()
+}

src/kotlin/sequential/sorting/shellsort/_test/ShellSortTest.kt

@@ -0,0 +1,66 @@
+package sequential.sorting.shellsort.gapsequence
+
+import kotlin.math.ceil
+import kotlin.math.floor
+
+
+/**
+ * @see CiuraGapSequence
+ * @see TokudaGapSequence
+ */
+object CiuraExtendedGapSequence {
+
+    /**
+     * Precomputed gap sequence for arrays of integer range.
+     */
+    val get = intArrayOf(
+            954437177, 424194301, 188530801, 83791468, 37240653, 16551402, 7356179, 3269413,
+            1453073, 645811, 287028, 127568, 56697, 25199, 11200, 4978, 2213, 1750, 701, 301, 132,
+            57, 23, 10, 4, 1
+    )
+
+    /**
+     * Computes gap sequence for the given array size.
+     */
+    fun compute(arraySize: Int): IntArray {
+        if (arraySize <= 1) return intArrayOf(1)
+
+        val base = CiuraGapSequence.get
+        if (arraySize <= base[0]) return base
+
+        var k = base.size
+        var gap = base[0]
+        do {
+            gap = computeTerm(gap)
+            k++
+        } while (gap < arraySize)
+
+        val gaps = IntArray(--k)
+        val extensionSize = gaps.size - base.size
+
+        for (i in 0..gaps.lastIndex) {
+            gaps[i] = if (i < extensionSize) {
+                gap = computeReverseTerm(gap)
+                gap
+            } else base[i - extensionSize]
+        }
+
+        return gaps
+    }
+
+
+    /**
+     * General term of the gap sequence.
+     *
+     * @param h previous sequence term.
+     * @return next sequence term.
+     */
+    private fun computeTerm(h: Int) =
+            floor(h * 2.25).toInt()
+
+    /**
+     * Reverse operation to [computeTerm].
+     */
+    private fun computeReverseTerm(h: Int) =
+            ceil(h / 2.25).toInt()
+}

src/kotlin/sequential/sorting/shellsort/gapsequence/248GapSequence.kt

@@ -0,0 +1,19 @@
+package sequential.sorting.shellsort.gapsequence
+
+
+/**
+ * Experimentally derived gap sequence by Marcin Ciura (2001).
+ * Originally the sequence consisted of the  first 8 elements but was extended by Roman Dovgopolov
+ * in 2011 by adding 1750.
+ *
+ * @see [Best Increments for the Average Case of Shellsort](https://doi.org/10.1007/3-540-44669-9_12)
+ */
+object CiuraGapSequence {
+
+    /**
+     * Experimentally derived gap sequence.
+     */
+    val get = intArrayOf(
+            1750, 701, 301, 132, 57, 23, 10, 4, 1
+    )
+}