Design a data structure that follows the constraints of a Least Recently Used (LRU) cache

LruCache.kt

class LRUCache(private val capacity: Int) {

    inner class Node(
        val key: Int,
        val value: Int,
        var next: Node? = null,
        var prev: Node? = null
    )

    private val cache = mutableMapOf<Int, Node>()
    private val left = Node(0, 0)
    private val right = Node(0, 0)

    init {
        left.next = right
        right.prev = left
    }

    fun get(key: Int): Int {
        return cache[key]?.let { node ->
            remove(node)
            insert(node)
            node.value
        } ?: -1
    }

    fun put(key: Int, value: Int) {
        cache[key]?.let { node ->
            remove(node)
            cache.remove(key)
        }

        val node = Node(key, value)
        insert(node)
        cache[key] = node

        if (cache.size > capacity) {
            left.next?.let { lruNode ->
                remove(lruNode)
                cache.remove(lruNode.key)
            }
        }
    }

    private fun remove(node: Node) {
        val prev = node.prev
        val next = node.next
        prev?.next = next
        next?.prev = prev
    }

    private fun insert(node: Node) {
        val prev = right.prev
        val next = right
        prev?.next = node
        next.prev = node
        node.prev = prev
        node.next = next
    }
}