How to Implement Linked List in Kotlin: Simple Guide

To implement a linked list in Kotlin, create a Node class holding data and a reference to the next node. Then build a LinkedList class to manage nodes with functions to add, remove, and traverse elements.

Syntax

A linked list in Kotlin typically uses a Node class to hold the value and a reference to the next node. The LinkedList class manages the nodes and provides methods to add or remove elements.

• Node class: Holds data and a pointer to the next node.
• LinkedList class: Contains the head node and functions to manipulate the list.

kotlin

class Node<T>(var data: T) {
    var next: Node<T>? = null
}

class LinkedList<T> {
    private var head: Node<T>? = null

    fun add(data: T) {
        val newNode = Node(data)
        if (head == null) {
            head = newNode
        } else {
            var current = head
            while (current?.next != null) {
                current = current.next
            }
            current?.next = newNode
        }
    }

    fun printList() {
        var current = head
        while (current != null) {
            print("${'$'}{current.data} -> ")
            current = current.next
        }
        println("null")
    }
}

Example

This example shows how to create a linked list, add elements, and print the list to see the order of nodes.

kotlin

fun main() {
    val list = LinkedList<Int>()
    list.add(10)
    list.add(20)
    list.add(30)
    list.printList()
}

Output

10 -> 20 -> 30 -> null

Common Pitfalls

Common mistakes when implementing linked lists include:

• Not updating the next pointer correctly, causing lost nodes.
• Forgetting to handle the empty list case when adding or removing nodes.
• Not checking for null when traversing the list, leading to errors.

Always ensure you update references carefully and check for null to avoid crashes.

kotlin

/* Wrong way: forgetting to update next pointer */
fun addWrong(data: T) {
    val newNode = Node(data)
    if (head == null) {
        head = newNode
    } else {
        var current = head
        while (current?.next != null) {
            current = current.next
        }
        // Forgot to set current.next = newNode
    }
}

/* Right way: */
fun addRight(data: T) {
    val newNode = Node(data)
    if (head == null) {
        head = newNode
    } else {
        var current = head
        while (current?.next != null) {
            current = current.next
        }
        current?.next = newNode
    }
}

Quick Reference

Remember these key points when working with linked lists in Kotlin:

• Use a Node class with data and next pointer.
• Manage the head node carefully in your LinkedList class.
• Always check for null when traversing or modifying the list.
• Update pointers correctly to avoid losing nodes.

Key Takeaways

Implement a linked list by creating a Node class with data and a next reference.

Manage the head node and update next pointers carefully to maintain the list.

Always check for null when traversing to avoid runtime errors.

Test adding and printing nodes to verify your linked list works correctly.