update

src/main/kotlin/03-linked-list/LinkedList.kt

@@ -1,11 +1,13 @@
 package `03-linked-list`
 
-class LinkedList<T : Any> {
+class LinkedList<T : Any> : Iterable<T>,
+    Collection<T>, MutableIterable<T>, MutableCollection<T> {
     private var head: Node<T>? = null
     private var tail: Node<T>? = null
-    private var size = 0
+    override var size = 0
+        private set
 
-    fun isEmpty(): Boolean {
+    override fun isEmpty(): Boolean {
         return size == 0
     }
 
@@ -121,5 +123,53 @@ class LinkedList<T : Any> {
         return result
     }
 
+    override fun iterator(): MutableIterator<T> {
+        return LinkedListIterator(this)
+    }
+
+    override fun contains(element: T): Boolean {
+        for (item in this) {
+            if (item == element) return true
+        }
+        return false
+    }
+
+    override fun containsAll(elements: Collection<T>): Boolean {
+        for (searched in elements) {
+            if (!contains(searched)) return false
+        }
+        return true
+    }
+
+    override fun add(element: T): Boolean {
+        append(element)
+        return true
+    }
+
+    override fun addAll(elements: Collection<T>): Boolean {
+        for (element in elements) {
+            append(element)
+        }
+        return true
+    }
+
+    override fun clear() {
+        head = null
+        tail = null
+        size = 0
+    }
+
+    override fun remove(element: T): Boolean {
+        TODO("Not yet implemented")
+    }
+
+    override fun removeAll(elements: Collection<T>): Boolean {
+        TODO("Not yet implemented")
+    }
+
+    override fun retainAll(elements: Collection<T>): Boolean {
+        TODO("Not yet implemented")
+    }
+
 
 }

src/main/kotlin/03-linked-list/LinkedListIterator.kt

@@ -0,0 +1,34 @@
+package `03-linked-list`
+
+class LinkedListIterator<T : Any>(private val list: LinkedList<T>) : Iterator<T>, MutableIterator<T> {
+    private var index = 0
+    private var lastNode: Node<T>? = null
+
+    override fun hasNext(): Boolean {
+        return index < list.size
+    }
+
+    override fun next(): T {
+        if (index >= list.size) throw IndexOutOfBoundsException()
+
+        lastNode = if (index == 0) {
+            list.nodeAt(0)
+        } else {
+            lastNode?.next
+        }
+        index++
+        return lastNode!!.value
+    }
+
+    override fun remove() {
+        if (index == 1) {
+            list.pop()
+        } else {
+            val prevNode = list.nodeAt(index - 2) ?: return
+
+            list.removeAfter(prevNode)
+            lastNode = prevNode
+        }
+        index--
+    }
+}