Add Linked List

* Flatten Multi Level List
* Remove Kth Last Node
* Linked List Reversal
* Linked List Intersection
* Palindromic Linked List
* LRU Cache

Author: marttp

kotlin/Linked Lists/FlattenMultiLevelList.kt

@@ -0,0 +1,37 @@
+import ds.MultiLevelListNode
+
+/*
+    Definition for a MultiLevelListNode:
+    data class MultiLevelListNode(
+            var value: Int,
+            var next: MultiLevelListNode? = null,
+            var child: MultiLevelListNode? = null
+    )
+*/
+
+fun flattenMultiLevelList(head: MultiLevelListNode?): MultiLevelListNode? {
+    if (head == null) {
+        return null
+    }
+    var tail = head
+    // Find the tail of the linked list at the first level.
+    while (tail?.next != null) {
+        tail = tail.next
+    }
+    var curr = head
+    // Process each node at the current level. If a node has a child linked list,
+    // append it to the tail and then update the tail to the end of the extended
+    // linked list. Continue until all nodes at the current level are processed.
+    while (curr != null) {
+        if (curr.child != null) {
+            tail?.next = curr.child
+            // Disconnect the child linked list from the current node.
+            curr.child = null
+            while (tail?.next != null) {
+                tail = tail.next
+            }
+        }
+        curr = curr.next
+    }
+    return head
+}

kotlin/Linked Lists/LRUCache.kt

@@ -0,0 +1,66 @@
+data class DoublyLinkedListNode(val key: Int, val value: Int) {
+    var next: DoublyLinkedListNode? = null
+    var prev: DoublyLinkedListNode? = null
+}
+
+class LRUCache {
+
+    private val capacity: Int
+    private val hashmap: MutableMap<Int, DoublyLinkedListNode>
+    private val head: DoublyLinkedListNode
+    private val tail: DoublyLinkedListNode
+
+    constructor(capacity: Int) {
+        this.capacity = capacity
+        // A hash map that maps keys to nodes.
+        this.hashmap = mutableMapOf()
+        // Initialize the head and tail dummy nodes and connect them to
+        // each other to establish a basic two-node doubly linked list.
+        this.head = DoublyLinkedListNode(-1, -1)
+        this.tail = DoublyLinkedListNode(-1, -1)
+        this.head.next = this.tail
+        this.tail.prev = this.head
+    }
+
+    fun get(key: Int): Int {
+        if (key !in hashmap) {
+            return -1
+        }
+        // To make this key the most recently used, remove its node and
+        // re-add it to the tail of the linked list.
+        val node = hashmap[key]!!
+        removeNode(node)
+        addNodeToTail(node)
+        return node.value
+    }
+
+    fun put(key: Int, value: Int) {
+        // If a node with this key already exists, remove it from the
+        // linked list.
+        if (key in hashmap) {
+            removeNode(hashmap[key]!!)
+        }
+        val node = DoublyLinkedListNode(key, value)
+        hashmap[key] = node
+        // Remove the least recently used node from the cache if adding
+        // this new node will result in an overflow.
+        if (hashmap.size > capacity) {
+            hashmap.remove(head.next!!.key)
+            removeNode(head.next!!)
+        }
+        addNodeToTail(node)
+    }
+
+    private fun addNodeToTail(node: DoublyLinkedListNode) {
+        val prevNode = tail.prev
+        node.prev = prevNode
+        node.next = tail
+        prevNode!!.next = node
+        tail.prev = node
+    }
+
+    private fun removeNode(node: DoublyLinkedListNode) {
+        node.prev!!.next = node.next
+        node.next!!.prev = node.prev
+    }
+}

kotlin/Linked Lists/LinkedListIntersection.kt

@@ -0,0 +1,25 @@
+import ds.ListNode
+
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int = 0, var next: ListNode? = null)
+*/
+
+fun linkedListIntersection(headA: ListNode?, headB: ListNode?): ListNode? {
+    var ptrA = headA
+    var ptrB = headB
+    // Traverse through list A with 'ptrA' and list B with 'ptrB'
+    // until they meet.
+    while (ptrA != ptrB) {
+        // Traverse list A -> list B by first traversing 'ptrA' and
+        // then, upon reaching the end of list A, continue the
+        // traversal from the head of list B.
+        ptrA = if (ptrA != null) ptrA.next else headB
+        // Simultaneously, traverse list B -> list A.
+        ptrB = if (ptrB != null) ptrB.next else headA
+    }
+    // At this point, 'ptrA' and 'ptrB' either point to the
+    // intersection node or both are null if the lists do not
+    // intersect. Return either pointer.
+    return ptrA
+}

kotlin/Linked Lists/LinkedListReversal.kt

@@ -0,0 +1,22 @@
+import ds.ListNode
+
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int = 0, var next: ListNode? = null)
+*/
+
+fun linkedListReversal(head: ListNode?): ListNode? {
+    var currNode = head
+    var prevNode: ListNode? = null
+    // Reverse the direction of each node's pointer until 'currNode' 
+    // is null.
+    while (currNode != null) {
+        val nextNode = currNode.next
+        currNode.next = prevNode
+        prevNode = currNode
+        currNode = nextNode
+    }
+    // 'prevNode' will be pointing at the head of the reversed linked 
+    // list.
+    return prevNode
+}

kotlin/Linked Lists/LinkedListReversalRecursive.kt

@@ -0,0 +1,20 @@
+import ds.ListNode
+
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int = 0, var next: ListNode? = null)
+*/
+
+fun linkedListReversalRecursive(head: ListNode?): ListNode? {
+    // Base cases.
+    if (head == null || head.next == null) {
+        return head
+    }
+    // Recursively reverse the sublist starting from the next node.
+    val newHead = linkedListReversalRecursive(head.next)
+    // Connect the reversed linked list to the head node to fully
+    // reverse the entire linked list.
+    head.next!!.next = head
+    head.next = null
+    return newHead
+}

kotlin/Linked Lists/PalindromicLinkedList.kt

@@ -0,0 +1,49 @@
+import ds.ListNode
+
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int = 0, var next: ListNode? = null)
+*/
+
+fun palindromicLinkedList(head: ListNode?): Boolean {
+    // Find the middle of the linked list and then reverse the second half of the
+    // linked list starting at this midpoint.
+    val mid = findMiddle(head)
+    val secondHead = reverseList(mid)
+    // Compare the first half and the reversed second half of the list
+    var ptr1 = head
+    var ptr2 = secondHead
+    var res = true
+    while (ptr2 != null) {
+        if (ptr1?.value != ptr2?.value) {
+            res = false
+        }
+        ptr1 = ptr1?.next
+        ptr2 = ptr2?.next
+    }
+    return res
+}
+
+// From the 'Reverse Linked List' problem.
+fun reverseList(head: ListNode?): ListNode? {
+    var prev: ListNode? = null
+    var curr = head
+    while (curr != null) {
+        val next = curr.next
+        curr.next = prev
+        prev = curr
+        curr = next
+    }
+    return prev
+}
+
+// From the 'Linked List Midpoint' problem.
+fun findMiddle(head: ListNode?): ListNode? {
+    var slow = head
+    var fast = head
+    while (fast != null && fast.next != null) {
+        slow = slow?.next
+        fast = fast.next?.next
+    }
+    return slow
+}

kotlin/Linked Lists/RemoveKthLastNode.kt

@@ -0,0 +1,30 @@
+import ds.ListNode
+
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int = 0, var next: ListNode? = null)
+*/
+
+fun removeKthLastNode(head: ListNode?, k: Int): ListNode? {
+    // A dummy node to ensure there's a node before 'head' in case we
+    // need to remove the head node.
+    val dummy = ListNode(-1)
+    dummy.next = head
+    var trailer = dummy
+    var leader = dummy
+    // Advance 'leader' k steps ahead.
+    repeat(k) {
+        // If k is larger than the length of the linked list, no node
+        // needs to be removed.
+        leader = leader.next ?: return head
+    }
+    // Move 'leader' to the end of the linked list, keeping 'trailer'
+    // k nodes behind.
+    while (leader.next != null) {
+        leader = leader.next!!
+        trailer = trailer.next!!
+    }
+    // Remove the kth node from the end.
+    trailer.next = trailer.next?.next
+    return dummy.next
+}