DEV Community: λeo

Kotlin Collections - sort

λeo — Sat, 29 Aug 2020 01:00:57 +0000

To sort elements in ascending order, use the sort method from the collections package.

The method can receive the start index and final index of the collection range which wants to be sorted.

The method is going to do all the sorting operations in place O(1) and it is going to take O(nlogn) runtime.

val intArray = intArrayOf(4, 3, 2, 1)
intArray.sort()
//[1,2,3,4]

With a range of indices

val intArray = intArrayOf(4, 3, 2, 1)
intArray.sort(0,3)
//[2,3,4,1]

Use the comparable interface to modify the sorting operation

class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

//Sorting people collection 
people.sort()

println(people) 
// [Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard]

Kotlin Collections - withIndex

λeo — Fri, 03 Jul 2020 14:46:17 +0000

To retrieve elements with an index from an iterable type use withIndex function.
The method iterates over an iterable type and creates another iterable type with indexed values.
It is going to take O(n) time and O(n) space.

Documentation:
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/with-index.html
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-indexed-value/


val listOfFruits : List<String> = listOf("pineapple", "apple", "orange") 
// ["pineapple", "apple", "orange"]

val fruitsWithIndex : Iterable<IndexedValue<String>> = listOfFruits.withIndex() 
//[IndexedValue(0,"pineapple"),IndexedValue(1,"apple"),IndexedValue(0,"orange"]

val firstFruit = fruitsWithIndex.elementAt(0)
println("Index: ${firstFruit.index}, Value: ${firstFruit.value}") 
//Index: 0, Value: pineapple

Kotlin Collections - zipWithNext

λeo — Mon, 22 Jun 2020 03:14:00 +0000

To retrieve adjacent elements from iterable type use zipWithNext function.

ZipWithNext method iterates over the iterable type and creates another iterable type to save the result.

It is going to take O(n) time and O(n) space.

Official Documentation

val numbers = listOf(1,2,3,4,5)

//Apply zipWithNext function to retrieve adjacent elements
val adjacentElements:List<Pair<Int,Int>> = numbers.zipWithNext()
//[(1,2),(2,3),(3,4),(4,5)]

//can modify the operation function to apply on each element.
val distanceBetweenNumbers:List<Int> = numbers.zipWithNext{ a, b -> b - a}
//[1,1,1,1]