List creation (listOf, mutableListOf) in Kotlin - Time & Space Complexity

Time Complexity: List creation (listOf, mutableListOf)

O(n)

Understanding Time Complexity

When we create lists in Kotlin, it is helpful to know how the time it takes grows as the list gets bigger.

We want to understand how the work done changes when we add more items to the list.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

val mutableNumbers = mutableListOf()
for (i in 1..5) {
    mutableNumbers.add(i)
}
    

This code creates a fixed list with 5 items and a mutable list where items are added one by one.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Adding items to the mutable list inside a loop.
• How many times: The add operation runs 5 times, once for each item.

How Execution Grows With Input

When the list size grows, the number of add operations grows the same way.

Input Size (n)	Approx. Operations
10	10 add operations
100	100 add operations
1000	1000 add operations

Pattern observation: The work grows directly with the number of items added.

Final Time Complexity

Time Complexity: O(n)

This means the time to create or fill the list grows in a straight line with the number of items.

Common Mistake

[X] Wrong: "Creating a list with many items is instant and does not depend on size."

[OK] Correct: Each item must be added or copied, so more items mean more work and more time.

Interview Connect

Understanding how list creation time grows helps you explain efficiency when working with collections in real projects.

Self-Check

"What if we used a different data structure like a linked list? How would the time complexity of adding items change?"

Practice

1. Which Kotlin function creates a list that cannot be changed after it is created?

easy

A. listOf

B. mutableListOf

C. arrayListOf

D. setOf

Solution

1. Step 1: Understand listOf behavior

   listOf creates a fixed list that cannot be changed after creation.

2. Step 2: Compare with mutableListOf

   mutableListOf creates a list that can be changed (add/remove items).

3. Final Answer:

   listOf -> Option A

4. Quick Check:

   Fixed list = listOf [OK]

Hint: Use listOf for fixed lists, mutableListOf for changeable lists [OK]

Common Mistakes:

• Confusing mutableListOf as fixed list
• Thinking arrayListOf is immutable
• Using setOf which creates a set, not a list

2. Which of the following is the correct syntax to create a mutable list of integers with values 1, 2, and 3?

easy

A. val list = listOf(1, 2, 3)

B. val list = mutableListOf(1, 2, 3)

C. val list = mutableList(1, 2, 3)

D. val list = list(1, 2, 3)

Solution

1. Step 1: Identify correct function name

   The correct function to create a mutable list is mutableListOf.

2. Step 2: Check syntax correctness

   Options C and D use invalid function names. val list = listOf(1, 2, 3) creates an immutable list.

3. Final Answer:

   val list = mutableListOf(1, 2, 3) -> Option B

4. Quick Check:

   Mutable list syntax = mutableListOf(...) [OK]

Hint: Remember mutableListOf has 'Of' at the end [OK]

Common Mistakes:

• Using listOf instead of mutableListOf for mutable lists
• Misspelling mutableListOf as mutableList
• Using list() which does not exist

3. What will be the output of this Kotlin code?

val list = listOf("apple", "banana", "cherry")
println(list[1])

medium

A. banana

B. IndexOutOfBoundsException

C. cherry

D. apple

Solution

1. Step 1: Understand list indexing

   Kotlin lists use zero-based indexing, so index 1 refers to the second item.

2. Step 2: Identify the item at index 1

   The list is ["apple", "banana", "cherry"], so index 1 is "banana".

3. Final Answer:

   banana -> Option A

4. Quick Check:

   Index 1 = second item = banana [OK]

Hint: Remember list indexes start at 0 in Kotlin [OK]

Common Mistakes:

• Thinking index 1 is the first item
• Expecting an error for valid index
• Confusing listOf with mutableListOf output

4. What is wrong with this Kotlin code?

val list = listOf(1, 2, 3)
list.add(4)

medium

A. add() method requires a mutableListOf list

B. Syntax error in listOf declaration

C. listOf creates an immutable list; add() is not allowed

D. No error; code runs fine

Solution

1. Step 1: Check list type

   listOf creates an immutable (read-only) list.

2. Step 2: Understand add() method

   The add() method is only available on mutable lists, not on immutable lists.

3. Final Answer:

   listOf creates an immutable list; add() is not allowed -> Option C

4. Quick Check:

   Immutable list cannot add items [OK]

Hint: Use mutableListOf to add or remove items [OK]

Common Mistakes:

• Trying to add to listOf list
• Ignoring immutability of listOf
• Assuming add() works on all lists

5. You want to create a list of strings that you can add items to later. Which Kotlin code correctly creates this list and adds "orange" to it?

hard

A. val fruits = mutableListOf("apple", "banana")
fruits = fruits + "orange"

B. val fruits = listOf("apple", "banana")
fruits.add("orange")

C. val fruits = listOf("apple", "banana")
fruits += "orange"

D. val fruits = mutableListOf("apple", "banana")
fruits.add("orange")

Solution

1. Step 1: Choose a mutable list

   To add items later, the list must be mutable, so use mutableListOf.

2. Step 2: Use add() method correctly

   Calling add("orange") on a mutable list adds the item successfully.

3. Step 3: Check other options

   val fruits = listOf("apple", "banana") fruits.add("orange") tries to add to immutable list (error). val fruits = listOf("apple", "banana") fruits += "orange" uses += on immutable list (creates new list but does not modify original). val fruits = mutableListOf("apple", "banana") fruits = fruits + "orange" tries to reassign val which is not allowed.

4. Final Answer:

   val fruits = mutableListOf("apple", "banana") fruits.add("orange") -> Option D

5. Quick Check:

   Mutable list + add() = correct way [OK]

Hint: Use mutableListOf and add() to change list after creation [OK]

Common Mistakes:

• Adding to immutable list
• Trying to reassign val variable
• Using += on immutable list expecting mutation