edited data structures docs and added some tests in GraphTest

Author: evitwilly

.gradle/7.1/executionHistory/executionHistory.bin

@@ -19,6 +19,7 @@ package structures
  *       \
  *        4
  * the same complexity is true for adding and removing nodes
+ *
  */
 
 class BinaryTree {
@@ -31,7 +32,7 @@ class BinaryTree {
     /**
      * adding a new element to the tree
      *
-     * @value - element value
+     * @param value - element value
      */
     fun add(value: Int) {
         fun addRec(current: Node?, value: Int) : Node {
@@ -59,7 +60,7 @@ class BinaryTree {
     /**
      * removing an element from the tree
      *
-     * @value - the value of the element to be removed
+     * @param value - the value of the element to be removed
      */
     fun remove(value: Int) {
         fun smallestValue(root: Node) : Int {
@@ -103,7 +104,7 @@ class BinaryTree {
     /**
      * checking for the existence of an element in the tree
      *
-     * @value - element value
+     * @param value - element value
      *
      * @return - returns true if the element exists
      */
@@ -115,7 +116,11 @@ class BinaryTree {
             if (value == current.value()) {
                 return true
             }
-            return if (value < current.value()) containsRec(current.leftNode(), value) else containsRec(current.rightNode(), value)
+            return if (value < current.value()) {
+                containsRec(current.leftNode(), value)
+            } else {
+                containsRec(current.rightNode(), value)
+            }
         }
 
         return containsRec(root, value)
@@ -203,12 +208,9 @@ class BinaryTree {
         while (queue.isNotEmpty()) {
             val node = queue.remove()
             items.add(node.value())
-            if (node.leftNode() != null) {
-                queue.add(node.leftNode()!!)
-            }
-            if (node.rightNode() != null) {
-                queue.add(node.rightNode()!!)
-            }
+
+            node.leftNode()?.let(queue::add)
+            node.rightNode()?.let(queue::add)
         }
 
         return items
@@ -219,9 +221,11 @@ class BinaryTree {
 /**
  * represents a tree node
  *
- * @value - node value
- * @left - left child node
- * @right - right child node
+ * @constructor
+ * @property value - node value
+ * @property left - left child node
+ * @property right - right child node
+ *
  */
 class Node(
     private var value: Int,

.gradle/7.1/executionHistory/executionHistory.lock

@@ -8,6 +8,7 @@ package structures
  * time to insert an element at the beginning and end of the list: O(1)
  * insertion time in the middle by index: O(n)
  * delete: O(n)
+ *
  */
 
 class CircularLinkedList<T>(
@@ -34,8 +35,10 @@ class CircularLinkedList<T>(
     /**
      * singly linked list node
      *
-     * @value - node value
-     * @next - link to the next element (assuming the element is not the last one)
+     * @constructor
+     * @property value - node value
+     * @property next - link to the next element (assuming the element is not the last one)
+     *
      */
     class Node<T>(
         private val value: T,
@@ -85,7 +88,7 @@ class CircularLinkedList<T>(
     /**
      * checks if an element is in the list
      *
-     * @value - element value
+     * @param value - element value
      *
      * @return returns true if the value exists in the list
      */
@@ -113,7 +116,7 @@ class CircularLinkedList<T>(
     /**
      * removes an element from the list
      *
-     * @value - element value
+     * @param value - element value
      *
      * @return returns true if the element was successfully removed
      */
@@ -146,8 +149,8 @@ class CircularLinkedList<T>(
     /**
      * add element by index
      *
-     * @index - the index where the new element should be added
-     * @value - the value of the new element
+     * @param index - the index where the new element should be added
+     * @param value - the value of the new element
      *
      * @return returns true if the element was successfully added at the specified index
      */
@@ -180,7 +183,7 @@ class CircularLinkedList<T>(
     /**
      * adds an element to the beginning of the list
      *
-     * @value - element value
+     * @param value - element value
      */
     fun addFirst(value: T) {
         val node = Node(value)
@@ -198,7 +201,7 @@ class CircularLinkedList<T>(
     /**
      * adds an element to the end of the list
      *
-     * @value - element value
+     * @param value - element value
      */
     fun addLast(value: T) {
         val newNode = Node(value)

.gradle/7.1/fileHashes/fileHashes.bin

@@ -34,9 +34,11 @@ class DoubleLinkedList<T>(
     /**
      * doubly linked list node
      *
-     * @value - node value
-     * @prev - link to the previous element (assuming the element is not the first one)
-     * @next - link to the next element (assuming the element is not the last one)
+     * @constructor
+     * @property value - node value
+     * @property prev - link to the previous element (assuming the element is not the first one)
+     * @property next - link to the next element (assuming the element is not the last one)
+     *
      */
     class Node<T>(
         private val value: T,
@@ -87,7 +89,7 @@ class DoubleLinkedList<T>(
     /**
      * checks if an element is in the list
      *
-     * @value - element value
+     * @param value - element value
      *
      * @return returns true if the value exists in the list
      */
@@ -114,7 +116,7 @@ class DoubleLinkedList<T>(
     /**
      * removes an element from the list
      *
-     * @value - element value
+     * @param value - element value
      *
      * @return returns true if the element was successfully removed
      */
@@ -151,8 +153,8 @@ class DoubleLinkedList<T>(
     /**
      * add element by index
      *
-     * @index - the index where the new element should be added
-     * @value - the value of the new element
+     * @param index - the index where the new element should be added
+     * @param value - the value of the new element
      *
      * @return returns true if the element was successfully added at the specified index
      */
@@ -191,7 +193,7 @@ class DoubleLinkedList<T>(
     /**
      * adds an element to the beginning of the list
      *
-     * @value - element value
+     * @param value - element value
      */
     fun addFirst(value: T) {
         val firstNode = first
@@ -212,7 +214,7 @@ class DoubleLinkedList<T>(
     /**
      * adds an element to the end of the list
      *
-     * @value - element value
+     * @param value - element value
      */
     fun addLast(value: T) {
         val lastNode = last

.gradle/7.1/fileHashes/fileHashes.lock

@@ -16,14 +16,14 @@ class Graph<T> {
     /**
      * adds a new vertex
      *
-     * @value - the value of the new vertex
+     * @param value - the value of the new vertex
      */
     fun addVertex(value: T) = data.putIfAbsent(Vertex(value), mutableListOf())
 
     /**
      * removes a vertex from a graph
      *
-     * @value - vertex value
+     * @param value - vertex value
      */
     fun removeVertex(value: T) {
         val removingVertex = Vertex(value)
@@ -36,8 +36,8 @@ class Graph<T> {
     /**
      * adds an edge between two vertices
      *
-     * @value1 - first vertex value
-     * @value2 - second vertex value
+     * @param value1 - first vertex value
+     * @param value2 - second vertex value
      */
     fun addEdge(value1: T, value2: T) {
         val vertex1 = Vertex(value1)
@@ -49,8 +49,8 @@ class Graph<T> {
     /**
      * removes an edge between two vertices
      *
-     * @value1 - first vertex value
-     * @value2 - second vertex value
+     * @param value1 - first vertex value
+     * @param value2 - second vertex value
      */
     fun removeEdge(value1: T, value2: T) {
         val vertex1 = Vertex(value1)
@@ -62,7 +62,7 @@ class Graph<T> {
     /**
      * returns the associated vertices with the given vertex
      *
-     * @value - vertex value
+     * @param value - vertex value
      */
     fun connectedVertexes(value: T) = data[Vertex(value)] ?: listOf()
 
@@ -93,8 +93,9 @@ class Graph<T> {
     fun breadthFirstTraversal() : List<Vertex<T>> {
         val visited = LinkedHashSet<Vertex<T>>()
         val queue = LinkedList<Vertex<T>>()
-        queue.add(data.keys.first())
-        visited.add(data.keys.first())
+        val firstVertex = data.keys.firstOrNull() ?: return listOf()
+        queue.add(firstVertex)
+        visited.add(firstVertex)
         while (queue.isNotEmpty()) {
             val vertex = queue.poll()
             data[vertex]?.forEach { v ->

.gradle/buildOutputCleanup/buildOutputCleanup.lock

@@ -16,7 +16,7 @@ package structures
  *
  */
 
-class MinHeap(private val maxSize: Int) {
+class MinHeap(maxSize: Int) {
 
     private val heap = Array(maxSize) { 0 }
 

src/main/kotlin/structures/BinaryTree.kt

@@ -3,16 +3,21 @@ package structures
 import java.lang.IllegalStateException
 
 /**
- * data structure: dynamic array
+ * data structure: simple java.util.ArrayList implementation
  *
  * description: wrapper over a regular array, in which indexes are checked and
  * when the array overflows, its size increases dynamically
  *
  * @constructor
- * @param capacity initial array size
+ * @property capacity initial array size
+ *
+ * P.S. Kotlin lists use under the hood java.util.ArrayList
+ * for example:
+ *     val numbers = listOf(1, 2, 3) // java.util.ArrayList
+ *     val symbols = mutableListOf('a', 'b', 'c') // also java.util.ArrayList
  */
 
-class DynamicArray(private var capacity: Int = 10) {
+class MyArrayList(private var capacity: Int = 10) {
     private var data = Array(capacity) { 0 }
     private var index = 0
 
@@ -90,8 +95,8 @@ class DynamicArray(private var capacity: Int = 10) {
     }
 
     /**
-     * returns the size of the array
      *
+     * @return returns the size of the array
      */
     fun capacity() = capacity
 

src/main/kotlin/structures/CircularLinkedList.kt

@@ -7,14 +7,15 @@ import kotlin.collections.ArrayList
  *
  * description: the queue is organized on a FIFO basis (first in, first out), all operations are performed in O(1),
  * except for the operation of deleting from the middle of the queue, which in the worst case takes O(n) time
+ *
  */
 
 interface Queue<T> {
 
     /**
      * adding to the front of the queue
      *
-     * @item - added element
+     * @param item - added element
      */
     fun offer(item: T)
 
@@ -47,8 +48,8 @@ interface Queue<T> {
     fun poll() : T?
 
     /**
-     * returns true if the queue is empty
      *
+     * @return returns true if the queue is empty
      */
     fun isEmpty() : Boolean
 
@@ -61,7 +62,7 @@ interface Queue<T> {
     /**
      * removes an element from the middle of the queue
      *
-     * returns true if the element was successfully removed
+     * @return returns true if the element was successfully removed
      */
     fun remove(item: T) : Boolean