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