Build a Singly Linked List

Construct a singly linked list by allocating one node per value and chaining next references. Establishes the node + head + tail model used by every later linked-list lesson.

Algorithm

Canonical input [10, 20, 30, 40] builds the chain head -> 10 -> 20 -> 30 -> 40 -> nil with one node appended per step.

Basic Implementation

basic.kt

class ListNode(var value: Int, var next: Int)

fun main() {
	val values = intArrayOf(10, 20, 30, 40)
	val nodes = mutableListOf<ListNode>()
	var head = -1
	var tail = -1
	for (i in values.indices) {
		val idx = nodes.size
		nodes.add(ListNode(values[i], -1))
		if (head == -1) {
			head = idx
		} else {
			nodes[tail].next = idx
		}
		tail = idx
	}
	var cur = head
	while (cur != -1) {
		print("${nodes[cur].value} -> ")
		cur = nodes[cur].next
	}
	println("nil")
}

Complexity

Time: O(n) with a tail pointer
Space: O(n) for the chain

Implementation notes

Kotlin: a tiny class ListNode(var value: Int, var next: Int) stored in a MutableList<ListNode> arena. The integer next field with -1 as the sentinel is the explicit "end-of-list" marker and lets the head / tail pointers update the chain without leaning on java.util.LinkedList.
The replay never shows runtime references; nodes are labelled node(<value>) and the chain view is rendered as 10 -> 20 -> ... -> nil.
The arena is collected by the JVM GC at scope exit, so the build step stays focused on wiring without an explicit free walk.

node chain Each `ListNode` carries an `Int value` and an `Int next` index into the node arena (`-1` is the end-of-list sentinel).