added comments and searchtree

Author: JakubSchwenkbeck

src/main/scala/algorithms/dynamic/Decomposition.scala

@@ -1,6 +1,18 @@
 package algorithms.dynamic
 
 // Bottom-up dynamic programming approach
+/// Compute the maximum revenue from rod decomposition using dynamic programming.
+///
+/// Given a rod of length `n` and an array `prices` where `prices(i)` represents the price of a rod of length `i+1`,
+/// the goal is to determine the optimal way to cut the rod to maximize revenue.
+///
+/// We use a **bottom-up dynamic programming** approach:
+///   - Define `dp(i)` as the maximum revenue obtainable for a rod of length `i`.
+///   - The recurrence relation is:
+///       dp(j) = max(prices(i) + dp(j - i - 1)) for all valid cuts i.
+///   - We iterate from length `1` to `n`, computing the best revenue for each length.
+///
+/// Time Complexity: **O(n²)** – We compute the maximum for each length `j` by iterating through all possible cuts `i`.
 def bottomUpDecomposition(prices: Array[Int], n: Int): Int = {
   val dp = Array.fill(n + 1)(0) // dp[i] stores the max revenue for length i
 

src/main/scala/algorithms/dynamic/MaxNonAdjacentWeight.scala

@@ -1,5 +1,15 @@
 package algorithms.dynamic
 
+/// Calculate the maximum weight sum of non-adjacent elements in an array.
+/// The function also returns the subsequence of selected elements.
+///
+/// Example:
+/// val arr = Array(3, 2, 7, 10)
+/// val (maxWeight, maxSequence) = maxNonAdjacentWeight(arr)
+/// println(s"Max weight: $maxWeight")  // Returns (13)
+/// println(s"Sequence: $maxSequence") // Returns (3, 10)
+///
+/// Time Complexity: O(n) – The DP table is filled once iteratively.
 def maxNonAdjacentWeight(a: Array[Int]): (Int, List[Int]) = {
   val n = a.length
   if (n == 0) return (0, List())

src/main/scala/algorithms/dynamic/OptimalMatrix.scala

@@ -2,6 +2,15 @@ package algorithms.dynamic
 
 case class Matrix(n: Int, m: Int)
 
+/// Find the optimal way to parenthesize matrix chain multiplication to minimize scalar multiplications.
+/// The function returns the minimal number of scalar multiplications and the DP table for matrix splits.
+///
+/// Example:
+/// val matrices = Array(Matrix(5, 10), Matrix(10, 3), Matrix(3, 12))
+/// val (num, res) = optimalMatrixParentheses(matrices)
+/// println(s"Minimal scalar multiplications: $num")  // Returns 330
+///
+/// Time Complexity: O(n³) – Triple nested loop for DP table computation.
 def optimalMatrixParentheses(lst: Array[Matrix]): (Int, Array[Array[Int]]) = {
   val length = lst.length
   val dp: Array[Array[Int]] = Array.fill(length, length)(0)

src/main/scala/algorithms/dynamic/OptimalStops.scala

@@ -2,6 +2,17 @@ package algorithms.dynamic
 
 case class Result(route: List[Int], minCost: Int)
 
+/// Find the optimal set of stops along a route to minimize the penalty for deviating from 200km/day driving distance.
+/// The penalty is based on the square of the difference between the ideal 200km and the actual distance driven each day.
+/// The function returns the optimal stops and the minimum penalty cost.
+///
+/// Example:
+/// val hotels = Array(0, 100, 250, 400, 600, 800)
+/// val result = findOptimalStops(hotels)
+/// println(s"Optimal stops: ${result.route}")  // [0, 250, 400,600, 800]
+/// println(s"Minimum penalty: ${result.minCost}")  // Minimum penalty : 500
+///
+/// Time Complexity: O(n²) – Nested loops for dynamic programming.
 def findOptimalStops(a: Array[Int]): Result = {
   val n = a.length
   val dp = Array.fill(n)(Int.MaxValue) // Minimum penalty cost up to hotel i

src/main/scala/datastructures/basic/LinkedList.scala

@@ -1,4 +1,9 @@
 package datastructures.basic
 
-// Define the Node class for the linked list
+/// Define a node for a singly linked list. Each node stores a value and a reference to the next node.
+///
+/// Time Complexity:
+/// - Accessing the value: O(1)
+/// - Insertion/Deletion: O(1) at the head (or known position)
+
 class LinkedNode[T](val value: T, var next: Option[LinkedNode[T]] = None)

src/main/scala/datastructures/basic/PriorityQueue.scala

@@ -2,6 +2,14 @@ package datastructures.basic
 
 import datastructures.heap.MaxHeap
 
+/// A priority queue implemented using a max-heap. Supports enqueue, dequeue, peek, size, and isEmpty operations.
+///
+/// Time Complexity:
+/// - Enqueue (insert): O(log n)
+/// - Dequeue (extractMax): O(log n)
+/// - Peek (peekMax): O(1)
+/// - isEmpty: O(1)
+/// - Size: O(1)
 class PriorityQueue[T](implicit ord: Ordering[T]) {
   private val maxHeap = new MaxHeap[T]()
 

src/main/scala/datastructures/hash/LinearProbingHashTable.scala

@@ -2,6 +2,14 @@ package datastructures.hash
 
 import scala.collection.mutable.ArrayBuffer
 
+/// A hash table implementation using linear probing for collision resolution.
+///
+/// Time Complexity:
+/// - Insert: O(1) average, O(n) worst-case (when resizing)
+/// - Get: O(1) average, O(n) worst-case (due to probing)
+/// - Remove: O(1) average, O(n) worst-case (due to probing)
+/// - Contains: O(1) average, O(n) worst-case (due to probing)
+/// - Resize: O(n) when triggered
 class LinearProbingHashTable[K, V](initialSize: Int = 16) {
   private var size = 0
   private var table: ArrayBuffer[Option[(K, V)]] = ArrayBuffer.fill(initialSize)(None)

src/main/scala/datastructures/heap/MaxHeap.scala

@@ -2,6 +2,14 @@ package datastructures.heap
 
 import scala.collection.mutable.ArrayBuffer
 
+/// A max-heap implementation. Supports insert, extractMax, peekMax, and heap size operations.
+///
+/// Time Complexity:
+/// - Insert: O(log n)
+/// - ExtractMax: O(log n)
+/// - PeekMax: O(1)
+/// - Size: O(1)
+/// - IsEmpty: O(1)
 class MaxHeap[T](implicit ord: Ordering[T]) {
   private val heap: ArrayBuffer[T] = ArrayBuffer.empty[T]
 

src/main/scala/datastructures/heap/MinHeap.scala

@@ -2,6 +2,17 @@ package datastructures.heap
 
 import scala.collection.mutable.ArrayBuffer
 
+/// A min-heap implementation. Supports insert, extractMin, peekMin, key modifications, and heap-building operations.
+///
+/// Time Complexity:
+/// - Insert: O(log n)
+/// - ExtractMin: O(log n)
+/// - PeekMin: O(1)
+/// - BuildHeap: O(n)
+/// - IncreaseKey: O(log n)
+/// - DecreaseKey: O(log n)
+/// - Size: O(1)
+/// - IsEmpty: O(1)
 class MinHeap[T](implicit ord: Ordering[T]) {
   private val heap: ArrayBuffer[T] = ArrayBuffer.empty[T]
 

src/main/scala/datastructures/tree/AVLTree.scala

@@ -1,3 +1,14 @@
+package datastructures.tree
+/// AVL Tree implementation with balancing on insertions.
+///
+/// Basic Operations:
+///   - `search(value)`: O(log n) – Finds a node with the given value.
+///   - `insert(newKey)`: O(log n) – Inserts a new key and balances the tree.
+///   - Balancing after insertions ensures that the tree remains balanced with height at most O(log n).
+///
+/// Rotations:
+///   - Right and Left Rotations: O(1) – Performed during rebalancing.
+
 case class AVLTree[T](key: T, left: Option[AVLTree[T]] = None, right: Option[AVLTree[T]] = None, height: Int = 1) {
 
   // Get the height of the tree or subtree

src/main/scala/datastructures/tree/BTree.scala

@@ -1,3 +1,17 @@
+package datastructures.tree
+
+/// B-Tree implementation with automatic balancing during insertion.
+///
+/// Basic Operations:
+///   - `search(value)`: O(log n) – Searches for the key in the tree.
+///   - `insert(newKey)`: O(log n) – Inserts a new key and ensures the tree remains balanced.
+///
+/// Insertion:
+///   - The tree splits when a node exceeds the maximum number of keys (`maxKeys`), ensuring balanced growth. Each insertion triggers O(log n) rebalancing and potential splits.
+///
+/// Node Splitting:
+///   - When a node exceeds the max number of keys, it splits into two, promoting the middle key to the parent. Splitting happens in O(log n) time.
+
 case class BTree[T: Ordering](keys: List[T] = List(), children: List[BTree[T]] = List(), maxKeys: Int = 2) {
 
   def isLeaf: Boolean = children.isEmpty

src/main/scala/datastructures/tree/SearchTree.scala

@@ -1,3 +1,74 @@
 package datastructures.tree
 
-class SearchTree
+// Node class to represent each element of the tree
+case class Node[T](value: T, left: Option[Node[T]] = None, right: Option[Node[T]] = None)
+
+// A simple implementation of a Binary Search Tree (BST)
+
+// Time Complexity of Basic Operations:
+//   - Insert: O(log n) on average, O(n) in the worst case (unbalanced tree).
+//   - Search: O(log n) on average, O(n) in the worst case (unbalanced tree).
+//   - Get Min/Max: O(log n) on average, O(n) in the worst case (unbalanced tree).
+
+class SearchTree[T: Ordering](var root: Option[Node[T]] = None) {
+
+  // Insert a new element into the tree
+  def insert(value: T): Unit = {
+    root match {
+      case Some(r) => insertRecursive(r, value)
+      case None    => root = Some(Node(value))
+    }
+  }
+
+  // Recursive helper function to insert a new value
+  private def insertRecursive(node: Node[T], value: T): Node[T] = {
+    if (implicitly[Ordering[T]].lt(value, node.value)) {
+      node.copy(left = Some(node.left match {
+        case Some(leftNode) => insertRecursive(leftNode, value)
+        case None           => Node(value)
+      }))
+    } else {
+      node.copy(right = Some(node.right match {
+        case Some(rightNode) => insertRecursive(rightNode, value)
+        case None            => Node(value)
+      }))
+    }
+  }
+
+  // Search for a value in the tree
+  def search(value: T): Option[T] = searchRecursive(root, value)
+
+  // Recursive helper function to search for a value
+  private def searchRecursive(node: Option[Node[T]], value: T): Option[T] = {
+    node match {
+      case Some(n) if n.value == value                           => Some(n.value)
+      case Some(n) if implicitly[Ordering[T]].lt(value, n.value) => searchRecursive(n.left, value)
+      case Some(n)                                               => searchRecursive(n.right, value)
+      case None                                                  => None
+    }
+  }
+
+  // Get the minimum value in the tree
+  def getMin: Option[T] = findMin(root)
+
+  // Helper function to find the minimum value
+  private def findMin(node: Option[Node[T]]): Option[T] = {
+    node match {
+      case Some(n) if n.left.isEmpty => Some(n.value)
+      case Some(n)                   => findMin(n.left)
+      case None                      => None
+    }
+  }
+
+  // Get the maximum value in the tree
+  def getMax: Option[T] = findMax(root)
+
+  // Helper function to find the maximum value
+  private def findMax(node: Option[Node[T]]): Option[T] = {
+    node match {
+      case Some(n) if n.right.isEmpty => Some(n.value)
+      case Some(n)                    => findMax(n.right)
+      case None                       => None
+    }
+  }
+}