├── LICENSE
├── README.md
└── src
    └── com
        └── freaklius
            └── kotlin
                └── algorithms
                    └── sort
                        ├── BogoSort.kt
                        ├── BubbleSort.kt
                        ├── BucketSort.kt
                        ├── CombSort.kt
                        ├── CountingSort.kt
                        ├── HeapSort.kt
                        ├── InsertionSort.kt
                        ├── MergeSort.kt
                        ├── QuickSort.kt
                        ├── RadixSort.kt
                        ├── SelectionSort.kt
                        ├── SortAlgorithm.kt
                        ├── SortLauncher.kt
                        └── Util.kt


/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (C) 2013 Ivan Krutov
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | This repository contains Kotlin implementation of simple and well-known algorithms and data structures.


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/BogoSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * An implementation of the most stupid sort algorithm =P
 5 |  * AveragePerformance = O(n*n!) -> Infinity
 6 |  */
 7 | class BogoSort : SortAlgorithm{
 8 | 
 9 |     override fun sort(arr: Array<Long>) : Array<Long>{
10 |         while(!isSortedAsc(arr)){
11 |             shuffleArray(arr)
12 |         }
13 |         return arr
14 |     }
15 | 
16 |     override fun getName(): String {
17 |         return "BogoSort"
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/BubbleSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * Bubble sort algorithm
 5 |  * AveragePerformance = O(n^2)
 6 |  */
 7 | class BubbleSort : SortAlgorithm{
 8 | 
 9 |     override fun sort(arr: Array<Long>): Array<Long> {
10 |         var swappedElements : Boolean
11 |         var level = arr.size - 1
12 |         do {
13 |             swappedElements = false
14 |             for (i in 0..level - 1){
15 |                 if (arr[i] > arr[i + 1]){
16 |                     swap(arr, i, i + 1)
17 |                     swappedElements = true
18 |                 }
19 |             }
20 |             level--
21 |         } while (swappedElements)
22 |         return arr
23 |     }
24 | 
25 |     override fun getName(): String {
26 |         return "BubbleSort"
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/BucketSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | import java.util.LinkedList
 4 | 
 5 | /**
 6 |  * Bucket sort algorithm
 7 |  * Average performance = O(n)
 8 |  */
 9 | class BucketSort : SortAlgorithm {
10 | 
11 |     override fun sort(arr: Array<Long>): Array<Long> {
12 |         //Number of buckets can depend on input array size
13 |         val numberOfBuckets = if (arr.size > 100) Math.floor(arr.size / 10.0).toInt() else 10
14 |         val outputArray = arr
15 |         val sortArray = Array<LinkedList<Long>>(numberOfBuckets, { i -> LinkedList()}) //We need to store digits in range 0..9
16 |         val maxArrayValue = maximum(arr)
17 |         for (i in 0..arr.size - 1){
18 |             val value = arr[i]
19 |             var valueIndex = Math.floor((numberOfBuckets * (value / maxArrayValue)).toDouble()).toInt() // It's a number in range 0..9
20 |             if (valueIndex == arr.size){
21 |                 valueIndex = arr.size - 1 //Maximum values go to the last bucket
22 |             }
23 |             sortArray[valueIndex].add(value)
24 |         }
25 |         var outputArrayIndex = 0
26 |         for (list in sortArray){
27 |             if (list.size > 0){
28 |                 val arrayFromList = Array<Long>(list.size, { i -> list.get(i)})
29 |                 for (value in InsertionSort().sort(arrayFromList)){
30 |                     outputArray[outputArrayIndex] = value
31 |                     outputArrayIndex++
32 |                 }
33 |             }
34 |         }
35 |         return outputArray
36 |     }
37 | 
38 |     override fun getName(): String {
39 |         return "BucketSort"
40 |     }
41 | }


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/CombSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * An implementation of CombSort algorithm
 5 |  * AveragePerformance = O(n^2/p)
 6 |  */
 7 | class CombSort : SortAlgorithm {
 8 | 
 9 |     override fun sort(arr: Array<Long>): Array<Long> {
10 |         var gap : Int = arr.size
11 |         val DIVISOR = 1.3 //Divisor to be used when decreasing gap
12 |         var swappedElements : Boolean
13 |         do {
14 |             gap = Math.floor((gap / DIVISOR)).toInt()
15 |             if (gap < 1){
16 |                 gap = 1
17 |             }
18 |             swappedElements = false
19 |             var i = 0
20 |             do {
21 |                 if (arr[i] > arr[i + gap]){
22 |                     swap(arr, i, i + gap)
23 |                     swappedElements = true
24 |                 }
25 |                 i++
26 |             } while (i + gap < arr.size)
27 |         } while ( (gap != 1) && swappedElements)
28 |         return arr
29 |     }
30 | 
31 |     override fun getName(): String {
32 |         return "CombSort"
33 |     }
34 | }


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/CountingSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * Counting sort algorithm implementation.
 5 |  * Input array should consist of integers only in the range 0..k, i.e. this sort algorithm works
 6 |  * only for bounded array. In this method we determine k using max() method - in reality we should pass it directly.
 7 |  * Average performance = O(n)
 8 |  */
 9 | class CountingSort : SortAlgorithm {
10 | 
11 |     override fun sort(arr: Array<Long>): Array<Long> {
12 |         val countsArray = Array<Int>(maximum(arr), { i -> 0})
13 |         //Determining counts of every integer in input array
14 |         for (i in 0..arr.size - 1){
15 |             val countsArrayIndex = arr[i].toInt() - 1 //Counts array is indexed by the values from the input array
16 |             countsArray[countsArrayIndex] = countsArray[countsArrayIndex] + 1
17 |         }
18 |         //Determining counts of integers smaller than current input array integer
19 |         for (j in 1..countsArray.size - 1){
20 |             countsArray[j] = countsArray[j] + countsArray[j - 1]
21 |         }
22 |         //Preparing sorted output array
23 |         val outputArray = Array<Long>(arr.size, { i -> 0})
24 |         var k = arr.size - 1
25 |         while(k >= 0){
26 |             val countsArrayIndex = arr[k].toInt() - 1
27 |             outputArray[countsArray[countsArrayIndex] - 1] = arr[k]
28 |             countsArray[countsArrayIndex]-- //Two equal input array elements should be placed in adjacent but different cells
29 |             k--
30 |         }
31 |         return outputArray
32 |     }
33 | 
34 |     override fun getName(): String {
35 |         return "CountingSort"
36 |     }
37 | }


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/HeapSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * Heap sort algorithm
 5 |  * AveragePerformance = O(n*lg(n))
 6 |  */
 7 | class HeapSort : SortAlgorithm {
 8 |     /**
 9 |      * Stores size of the heap to be used
10 |      */
11 |     private var heapSize = 0
12 | 
13 |     override fun sort(arr: Array<Long>): Array<Long> {
14 |         buildMaxHeap(arr)
15 |         var i: Int = arr.size - 1
16 |         while (i >= 1){
17 |             swap(arr, i, 0)
18 |             heapSize--
19 |             maxHeapify(arr, 0)
20 |             i--
21 |         }
22 |         return arr
23 |     }
24 | 
25 |     /**
26 |      * Builds a max-heap data structure from the input array (the original array is replaced) using maxHeapify method
27 |      * @param arr
28 |      */
29 |     private fun buildMaxHeap(arr: Array<Long>){
30 |         heapSize = arr.size
31 |         var i: Int = Math.floor(arr.size / 2.0).toInt()
32 |         while (i >= 0){
33 |             maxHeapify(arr, i)
34 |             i--
35 |         }
36 |     }
37 | 
38 |     /**
39 |      * Restores MaxHeap property starting from the array's ith element and going down
40 |      * @param arr
41 |      * @param i heap index where we need to check the property; we implicitly assume that child heaps conform to the
42 |      * MaxHeap property
43 |      */
44 |     private fun maxHeapify(arr: Array<Long>, i: Int){
45 |         val leftElementIndex = left(i)
46 |         val rightElementIndex = right(i)
47 |         var largestElementIndex : Int = i
48 | 
49 |         if ( (leftElementIndex <= heapSize - 1) && (arr[leftElementIndex] > arr[i]) ){
50 |             largestElementIndex = leftElementIndex
51 |         }
52 | 
53 |         if ( (rightElementIndex <= heapSize - 1) && (arr[rightElementIndex] > arr[largestElementIndex]) ){
54 |             largestElementIndex = rightElementIndex
55 |         }
56 | 
57 |         if (largestElementIndex != i){
58 |             swap(arr, i, largestElementIndex)
59 |             maxHeapify(arr, largestElementIndex)
60 |         }
61 |     }
62 | 
63 |     /**
64 |      * Returns the index of the array element corresponding to the left element of the ith element in the heap
65 |      * @param i an element to get the left element
66 |      */
67 |     private fun left(i: Int) : Int{
68 |         return 2 * i + 1
69 |     }
70 | 
71 |     /**
72 |      * Returns the index of the array element corresponding to the right element of the ith element in the heap
73 |      * @param i an element to get the left element
74 |      */
75 |     private fun right(i: Int) : Int{
76 |         return 2 * i + 2
77 |     }
78 | 
79 |     override fun getName(): String {
80 |         return "HeapSort"
81 |     }
82 | }


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/InsertionSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * An implementation of insertion sort algorithm
 5 |  * AveragePerformance = O(n^2)
 6 |  */
 7 | class InsertionSort : SortAlgorithm{
 8 | 
 9 |     override fun sort(arr: Array<Long>) : Array<Long>{
10 |         for (j in 1..arr.size - 1){
11 |             var i = j - 1
12 |             val processedValue = arr[j]
13 |             while ( (i >= 0) && (arr[i] > processedValue) ){
14 |                 arr[i + 1] = arr[i]
15 |                 i--
16 |             }
17 |             arr[i + 1] = processedValue
18 |         }
19 |         return arr
20 |     }
21 | 
22 | 
23 |     override fun getName(): String {
24 |         return "InsertionSort"
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/MergeSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * An implementation of merge sort procedure
 5 |  * AveragePerformance = O(n*lg(n)), where lg(n) is a logarithm of n for base 2
 6 |  */
 7 | class MergeSort : SortAlgorithm {
 8 | 
 9 |     override fun sort(arr: Array<Long>): Array<Long> {
10 |         sortArrayPiece(arr, 0, arr.size - 1)
11 |         return arr
12 |     }
13 | 
14 |     /**
15 |      * Sorts a piece of input array using recursive calls of itself
16 |      * @param arr
17 |      * @param fromIndex
18 |      * @param toIndex
19 |      */
20 |     private fun sortArrayPiece(arr: Array<Long>, startIndex: Int, endIndex: Int){
21 |         val pieceSize = endIndex - startIndex + 1
22 |         if (pieceSize == 1){
23 |             return //Single element piece case
24 |         }
25 |         val middleElementIndex = Math.floor((startIndex + endIndex) / 2.0).toInt()
26 |         sortArrayPiece(arr, startIndex, middleElementIndex)
27 |         sortArrayPiece(arr, middleElementIndex + 1, endIndex)
28 |         merge(arr, startIndex, middleElementIndex, endIndex)
29 |     }
30 | 
31 |     /**
32 |      * Merges two subarrays of initial array arr: [startIndex; middleIndex] and [middleIndex + 1; endIndex]
33 |      * in ascending order.
34 |      * @param arr
35 |      * @param startIndex
36 |      * @param middleIndex
37 |      * @param endIndex
38 |      */
39 |     private fun merge(arr: Array<Long>, startIndex: Int, middleIndex: Int, endIndex: Int){
40 |         val leftArray = arr.copyOfRange(startIndex, middleIndex + 1) //Left bound is exclusive, right - inclusive
41 |         val rightArray = arr.copyOfRange(middleIndex + 1, endIndex + 1)
42 |         var i = 0
43 |         var j = 0
44 |         for (k in startIndex..endIndex){
45 |             if ( (i <= leftArray.size - 1) && ( (j >= rightArray.size) || (leftArray[i] <= rightArray[j]) ) ){
46 |                 arr[k] = leftArray[i]
47 |                 i++
48 |             }else {
49 |                 arr[k] = rightArray[j]
50 |                 j++
51 |             }
52 |         }
53 |     }
54 | 
55 |     override fun getName(): String {
56 |         return "MergeSort"
57 |     }
58 | }


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/QuickSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * Quick sort algorithm implementation
 5 |  * AveragePerformance = O(n*lg(n))
 6 |  */
 7 | class QuickSort : SortAlgorithm {
 8 | 
 9 |     override fun sort(arr: Array<Long>): Array<Long> {
10 |         sortArrayPart(arr, 0, arr.size - 1)
11 |         return arr
12 |     }
13 | 
14 |     /**
15 |      * Swaps initial array elements having keys in [fromIndex; toIndex] range
16 |      * so that two subarrays are formed: leftArr[i] <= arr[middleIndex] <= rightArr[j]
17 |      * for any i, j and fromIndex <= middleIndex <= toIndex
18 |      * @param arr
19 |      * @param fromIndex
20 |      * @param toIndex
21 |      * @return returns middleIndex value
22 |      */
23 |     private fun partition(arr: Array<Long>, fromIndex: Int, toIndex: Int) : Int{
24 |         val lastElementValue = arr[toIndex]
25 |         var i = fromIndex - 1
26 |         for (j in fromIndex..toIndex - 1){
27 |             if (arr[j] <= lastElementValue){
28 |                 i++
29 |                 swap(arr, i, j)
30 |             }
31 |         }
32 |         //Swapping leftmost element of the second part with the last element of the array, i.e. with middle element
33 |         swap(arr, i + 1, toIndex)
34 |         return i + 1
35 |     }
36 | 
37 |     /**
38 |      * Sorts a part of input array
39 |      * @param arr
40 |      * @param fromIndex
41 |      * @param toIndex
42 |      */
43 |     private fun sortArrayPart(arr: Array<Long>, fromIndex: Int, toIndex: Int){
44 |         if (fromIndex < toIndex){
45 |             val middleIndex = partition(arr, fromIndex, toIndex)
46 |             sortArrayPart(arr, fromIndex, middleIndex - 1)
47 |             sortArrayPart(arr, middleIndex + 1, toIndex)
48 |         }
49 |     }
50 | 
51 |     override fun getName(): String {
52 |         return "QuickSort"
53 |     }
54 | }


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/RadixSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | import java.util.LinkedList
 4 | 
 5 | /**
 6 |  * Radix sort algorithm
 7 |  * Assumption: all sorted values has the same number of digits.
 8 |  * Average performance = O(n + k), where k is a number of digits
 9 |  */
10 | class RadixSort : SortAlgorithm {
11 | 
12 |     override fun sort(arr: Array<Long>): Array<Long> {
13 |         //The main idea is to sort input array by each digit using any sort algorithm
14 |         var outputArray = arr
15 |         for (digitNumber in 0..getMaximumDigitsCount(arr) - 1){
16 |             outputArray = sortArrayBySingleDigit(outputArray, digitNumber)
17 |         }
18 |         return outputArray
19 |     }
20 | 
21 |     /**
22 |      * Sorts input array by specified digit using counting sort algorithm. In fact this is a bucket sort
23 |      * where each of 10 buckets correspond to one of 10 possible decimal system digit values (from 0 to 9).
24 |      * @param arr
25 |      * @param digitNumber
26 |      */
27 |     private fun sortArrayBySingleDigit(arr: Array<Long>, digitNumber: Int) : Array<Long>{
28 |         val outputArray = arr
29 |         val mappingArray = Array<LinkedList<Long>>(10, { i -> LinkedList()}) //We need to store digits in range 0..9
30 |         for (i in 0..arr.size - 1){
31 |             val number = arr[i]
32 |             val digit = digitAt(number, digitNumber) // It's a number in range 0..9
33 |             mappingArray[digit].add(number)
34 |         }
35 |         var outputArrayIndex = 0
36 |         for (list in mappingArray){
37 |             if (list.size > 0){
38 |                 for (value in list){
39 |                     outputArray[outputArrayIndex] = value
40 |                     outputArrayIndex++
41 |                 }
42 |             }
43 |         }
44 |         return outputArray
45 |     }
46 | 
47 |     /**
48 |      * Returns digit positioned at specified position number starting from the right end.
49 |      * I.e. digitAt(123, 1) = 3; digitAt(123, 2) = 2 and so on.
50 |      * @param number
51 |      * @param digitNumber zero-based digit number
52 |      */
53 |     private fun digitAt(number: Long, digitNumber: Int) : Int{
54 |         val numberString = number.toString()
55 |         return if (digitNumber <= numberString.length - 1)
56 |             numberString.get(numberString.length - digitNumber - 1).toString().toInt() //Char.toInt() is a char code
57 |             else 0
58 |     }
59 | 
60 |     /**
61 |      * Returns maximum digits count assuming that input array is in decimal
62 |      */
63 |     private fun getMaximumDigitsCount(arr: Array<Long>) : Int{
64 |         return maximum(arr).toString().length
65 |     }
66 | 
67 |     override fun getName(): String {
68 |         return "RadixSort"
69 |     }
70 | }


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/SelectionSort.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * An implementation of selection sort algorithm
 5 |  * AveragePerformance = O(n^2)
 6 |  */
 7 | class SelectionSort : SortAlgorithm {
 8 | 
 9 |     override fun sort(arr: Array<Long>): Array<Long> {
10 |         for (unsortedPartFirstIndex in 0..arr.size - 1){
11 |             var minNumberIndex = unsortedPartFirstIndex
12 |             for (unsortedPartCurrentIndex in unsortedPartFirstIndex..arr.size - 1){
13 |                 if (arr[unsortedPartCurrentIndex] < arr[minNumberIndex]){
14 |                     minNumberIndex = unsortedPartCurrentIndex
15 |                 }
16 |             }
17 |             if (minNumberIndex != unsortedPartFirstIndex){
18 |                 swap(arr, unsortedPartFirstIndex, minNumberIndex)
19 |             }
20 |         }
21 |         return arr
22 |     }
23 |     override fun getName(): String {
24 |         return "SelectionSort"
25 |     }
26 | }


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/SortAlgorithm.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | /**
 4 |  * An abstract sort algorithm class (a base class for all sort algorithms)
 5 |  */
 6 | interface SortAlgorithm {
 7 |     /**
 8 |      * Sorts numbers using specified algorithm
 9 |      */
10 |     fun sort(arr: Array<Long>) : Array<Long>
11 | 
12 |     /**
13 |      * Returns algorithm name
14 |      */
15 |     fun getName() : String
16 | }


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/SortLauncher.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | 
 4 | /**
 5 |  * This class launches all specified sort algorithms and compares their performance
 6 |  */
 7 | class SortLauncher{
 8 | 
 9 |     /**
10 |      * Launches sort algorithms
11 |      */
12 |      fun launch() {
13 |         val arr: Array<Long> = randomNumericArray(10, 100)
14 |         for (algorithm in getAlgorithmsList()){
15 |             measureAlgorithm(arr.clone(), algorithm)
16 |         }
17 |     }
18 | 
19 |     /**
20 |      * Executes and measures a single algorithm
21 |      */
22 |     private fun measureAlgorithm(arr: Array<Long>, algorithm: SortAlgorithm){
23 | 
24 |         println("--------------------------------------")
25 |         println("Algorithm name: " + algorithm.getName())
26 |         println("Initial array: " + arrayToString(arr))
27 | 
28 |         val startTime : Long = System.nanoTime()
29 |         val sortedArr = algorithm.sort(arr)
30 |         val endTime : Long = System.nanoTime()
31 | 
32 |         println("Sorted array: " + arrayToString(sortedArr))
33 |         println("Is array sorted in ascending order: " + isSortedAsc(sortedArr))
34 | 
35 |         val avgTimePerElement : Double = ((endTime - startTime).toDouble() / arr.size.toDouble())
36 |         val runTime : Double = (endTime - startTime).toDouble()
37 |         println("Average time per element, ns: " + avgTimePerElement)
38 |         println("Total Array run time, ns: " + runTime)
39 |     }
40 | 
41 |     /**
42 |      * Returns a list of algorithms to be tested
43 |      */
44 |     private fun getAlgorithmsList() : Array<SortAlgorithm>{
45 |         return arrayOf(
46 |                 BubbleSort(),
47 |                 SelectionSort(),
48 |                 InsertionSort(),
49 |                 CombSort(),
50 |                 MergeSort(),
51 |                 HeapSort(),
52 |                 QuickSort(),
53 |                 CountingSort(),
54 |                RadixSort(),
55 |                 BucketSort(),
56 |                 BogoSort()
57 |         )
58 |     }
59 | }
60 | 
61 | /**
62 |  * Entry point function
63 |  */
64 | fun main(args: Array<String>) {
65 |     SortLauncher().launch()
66 | 
67 | }
68 | 


--------------------------------------------------------------------------------
/src/com/freaklius/kotlin/algorithms/sort/Util.kt:
--------------------------------------------------------------------------------
 1 | package com.freaklius.kotlin.algorithms.sort
 2 | 
 3 | import java.util.Random
 4 | 
 5 | /**
 6 |  * Contains a set of utility methods like printing array contents and so on
 7 |  */
 8 | 
 9 | /**
10 |  * Prints contents of an array
11 |  * @param arr an array to be converted to string
12 |  */
13 | fun <T> arrayToString(arr: Array<T> ) : String{
14 |     var str = "Array("
15 |     var isFirst = true
16 |     for (element in arr){
17 |         if (!isFirst){
18 |             str += ", "
19 |         }
20 |         str += element
21 |         if (isFirst){
22 |             isFirst = false
23 |         }
24 |     }
25 |     str += ")"
26 |     return str
27 | }
28 | 
29 | /**
30 |  * Returns a shuffled version of the input array
31 |  * @param arr an array to shuffle
32 |  */
33 | fun shuffleArray(arr: Array<Long>) : Array<Long>{
34 |     val rg = Random()
35 |     for (i in 0..arr.size - 1) {
36 |         val randomPosition = rg.nextInt(arr.size)
37 |         swap(arr, i, randomPosition)
38 |     }
39 |     return arr
40 | }
41 | 
42 | /**
43 |  * Swaps i-th and j-th elemens of the array
44 |  * @param arr
45 |  * @param i
46 |  * @param j
47 |  */
48 | fun swap(arr: Array<Long>, i: Int, j: Int) : Array<Long>{
49 |     val tmp : Long = arr[i]
50 |     arr[i] = arr[j]
51 |     arr[j] = tmp
52 |     return arr
53 | }
54 | 
55 | /**
56 |  * Creates random array or Long of given length and max value
57 |  * @param length length of an array to be generated
58 |  * @param maxValue
59 |  */
60 | fun randomNumericArray(length: Int, maxValue : Int = 10) : Array<Long>{
61 |     return Array<Long>(length, {i -> Math.round(maxValue * Math.random())})
62 | }
63 | 
64 | /**
65 |  * Returns whether given array is sorted in ascending order
66 |  * @param arr array to be checked
67 |  */
68 | fun isSortedAsc(arr: Array<Long>) : Boolean{
69 |     for (i in 0..arr.size - 2){
70 |         if (arr[i] > arr[i + 1]){
71 |             return false
72 |         }
73 |     }
74 |     return true
75 | }
76 | 
77 | /**
78 |  * Returns maximum value of an array (a linear complexity operation).
79 |  */
80 | fun maximum(arr: Array<Long>) : Int{
81 |     var max = 0
82 |     for (value in arr){
83 |         if (value > max){
84 |             max = value.toInt()
85 |         }
86 |     }
87 |     return max
88 | }


--------------------------------------------------------------------------------