Update DSA Notes

Author: VR-Rathod

pages/AA Tree.md

@@ -0,0 +1,88 @@
+# Explanation
+	- The **AA Tree** is a self-balancing binary search tree (BST). It’s a variation of the Red-Black Tree but with a simpler set of rules. The primary difference lies in how the tree is balanced, and it ensures that operations like insertion, deletion, and searching remain efficient.
+-
+- # Steps:
+	- The **balance condition** is enforced with a single balance factor for each node (the "level"), which simplifies the balancing process.
+	-
+	- **Level Rule**: The left child of a node must have the same level or one more level than its parent.
+	-
+	- **Rotation Rule**: The tree uses rotations (like right or left) to ensure the balance after insertion or deletion.
+-
+- # Time Complexity
+	- **Insertion**: O(log n)
+	- **Deletion**: O(log n)
+	- **Search**: O(log n)
+-
+- ```python
+  class AATreeNode:
+      def __init__(self, key):
+          self.key = key
+          self.level = 1
+          self.left = None
+          self.right = None
+  
+  class AATree:
+      def __init__(self):
+          self.root = None
+      
+      def skew(self, node):
+          if node and node.left and node.left.level == node.level:
+              node = self.rotate_right(node)
+          return node
+      
+      def split(self, node):
+          if node and node.right and node.right.right and node.right.right.level == node.level:
+              node = self.rotate_left(node)
+              node.level += 1
+          return node
+      
+      def rotate_right(self, node):
+          temp = node.left
+          node.left = temp.right
+          temp.right = node
+          return temp
+      
+      def rotate_left(self, node):
+          temp = node.right
+          node.right = temp.left
+          temp.left = node
+          return temp
+  
+      def insert(self, node, key):
+          if node is None:
+              return AATreeNode(key)
+          
+          if key < node.key:
+              node.left = self.insert(node.left, key)
+          elif key > node.key:
+              node.right = self.insert(node.right, key)
+          else:
+              return node
+  
+          node = self.skew(node)
+          node = self.split(node)
+          return node
+      
+      def search(self, node, key):
+          if node is None or node.key == key:
+              return node
+          elif key < node.key:
+              return self.search(node.left, key)
+          else:
+              return self.search(node.right, key)
+  
+      def add(self, key):
+          self.root = self.insert(self.root, key)
+  
+  # Example usage
+  aatree = AATree()
+  aatree.add(10)
+  aatree.add(20)
+  aatree.add(5)
+  
+  result = aatree.search(aatree.root, 10)
+  if result:
+      print(f"Found key {result.key}")
+  else:
+      print("Key not found")
+  ```

pages/Ackermann Function.md

@@ -0,0 +1,27 @@
+# Explanation
+	- The **Ackermann function** is a well-known recursive function that grows very quickly. It is often used in theoretical computer science to illustrate the difference between primitive recursive functions and general recursive functions.
+-
+- # Steps
+	- The function is defined as:
+	-
+	- A(0, n) = n + 1
+	-
+	- A(m, 0) = A(m - 1, 1) for m > 0
+	-
+	- A(m, n) = A(m - 1, A(m, n - 1)) for m > 0 and n > 0
+-
+- # Time Complexity
+	- The **time complexity** of the Ackermann function is not expressible in simple Big-O notation, as it grows faster than any primitive recursive function.
+-
+- ```python
+  def ackermann(m, n):
+      if m == 0:
+          return n + 1
+      elif m > 0 and n == 0:
+          return ackermann(m - 1, 1)
+      else:
+          return ackermann(m - 1, ackermann(m, n - 1))
+  
+  # Example usage
+  print(ackermann(3, 4))  # This will calculate A(3, 4)
+  ```

pages/Bellman Ford Algorithm.md

@@ -0,0 +1,32 @@
+# Explanation
+	- **Bellman-Ford Algorithm** is a dynamic programming algorithm used for finding the shortest path in graphs, even with negative weight edges. It also detects negative weight cycles.
+-
+- # Steps:
+	- Initialize distances to all vertices as infinity, and set the distance to the source vertex as 0.
+	- Relax all edges `V-1` times (where `V` is the number of vertices).
+	- Check for negative weight cycles by attempting to relax all edges once more.
+-
+- # Time Complexity:
+	- **O(V * E)**, where `V` is the number of vertices and `E` is the number of edges.
+-
+- ```python
+  def bellman_ford(graph, source, n):
+      dist = [float('inf')] * n
+      dist[source] = 0
+      for _ in range(n-1):
+          for u, v, w in graph:
+              if dist[u] + w < dist[v]:
+                  dist[v] = dist[u] + w
+      # Check for negative-weight cycles
+      for u, v, w in graph:
+          if dist[u] + w < dist[v]:
+              print("Graph contains negative weight cycle")
+              return
+      return dist
+  
+  # Example usage
+  graph = [(0, 1, -1), (0, 2, 4), (1, 2, 3), (1, 3, 2), (1, 4, 2), (3, 2, 5), (3, 4, -3), (4, 3, 3)]
+  n = 5
+  source = 0
+  print("Shortest distances:", bellman_ford(graph, source, n))
+  ```

pages/Binary Decision Diagram.md

@@ -0,0 +1,86 @@
+# Explanation
+	- A **Binary Decision Diagram (BDD)** is a data structure used to represent boolean functions. It uses a directed acyclic graph where each node represents a decision based on a variable, and the edges represent the outcomes of that decision.
+-
+- # Steps
+	- **Construct the decision diagram**: Represent the boolean function in terms of binary decisions.
+		- The diagram is built such that each node represents a binary decision based on a variable.
+		-
+		- The edges represent the outcome of that decision (true or false).
+	-
+	- **Minimize the diagram**: After constructing the initial BDD, apply techniques (like reduction rules) to minimize the number of nodes and edges. This step makes the BDD more efficient for function evaluation.
+	-
+	- **Evaluate the boolean function**: Once the BDD is constructed, evaluate the function by traversing the tree-like structure and applying the decisions.
+-
+- # Time Complexity
+	- O(n) for evaluating the boolean function, but complexity can vary depending on the size and structure of the diagram.
+	-
+	- **Construction**: O(n) where `n` is the number of variables, assuming the boolean function is represented as a decision tree.
+	-
+	- **Evaluation**: O(n) for evaluating the function, where `n` is the number of variables in the BDD (traversing each node once).
+-
+- ```python
+  class BDDNode:
+      def __init__(self, variable=None, high=None, low=None, value=None):
+          self.variable = variable  # Variable name
+          self.high = high  # Pointer to high branch (True)
+          self.low = low  # Pointer to low branch (False)
+          self.value = value  # Value for terminal nodes (True/False)
+  
+  class BDD:
+      def __init__(self):
+          self.nodes = {}  # Dictionary to store nodes for caching
+          self.var_count = 0  # Variable counter to name the variables
+  
+      def add_node(self, variable, high, low):
+          """Create a new node for the BDD."""
+          if (variable, high, low) in self.nodes:
+              return self.nodes[(variable, high, low)]  # Return cached node
+          node = BDDNode(variable, high, low)
+          self.nodes[(variable, high, low)] = node
+          return node
+  
+      def create_bdd(self, expression):
+          """Create a BDD for a given boolean expression."""
+          if not expression:
+              return None
+          if expression == "True":
+              return BDDNode(value=True)
+          if expression == "False":
+              return BDDNode(value=False)
+  
+          # Handle variable (e.g., "x1" or "x2")
+          var = expression[0]
+          high = self.create_bdd(expression[1:])
+          low = self.create_bdd(expression[1:])
+          
+          return self.add_node(var, high, low)
+  
+      def evaluate(self, node, assignments):
+          """Evaluate the BDD with the given variable assignments."""
+          if node is None:
+              return False
+  
+          if node.value is not None:  # Terminal node (True or False)
+              return node.value
+  
+          # Traverse according to the variable's value in assignments
+          var_value = assignments.get(node.variable)
+          if var_value:  # If True, move to the 'high' branch
+              return self.evaluate(node.high, assignments)
+          else:  # If False, move to the 'low' branch
+              return self.evaluate(node.low, assignments)
+  
+  # Example usage
+  bdd = BDD()
+  
+  # Constructing a simple BDD for the expression "x1 AND x2"
+  # This represents the boolean function x1 AND x2
+  bdd_root = bdd.create_bdd("x1x2")
+  
+  # Define variable assignments for testing
+  assignments = {"x1": True, "x2": True}
+  
+  # Evaluate the BDD with the assignments
+  result = bdd.evaluate(bdd_root, assignments)
+  print(f"Result of BDD evaluation: {result}")  # Expected output: True
+  ```

pages/Binary Indexed Tree or Fenwick Tree.md

@@ -0,0 +1,42 @@
+- Explanation:
+	- The **Binary Indexed Tree (BIT)**, also known as a **Fenwick Tree**, is a data structure that efficiently supports dynamic cumulative frequency tables.
+	-
+	- It allows you to compute prefix sums and update elements in **O(log n)** time. It is particularly useful for problems that require frequent range sum queries and updates.
+-
+- # Steps:
+	- The tree is implemented using an array, where each node represents a cumulative sum of elements.
+	-
+	- **Update Operation**: Updates an element in the array, and its impact propagates upward.
+	-
+	- **Query Operation**: Computes the sum of elements from the start to a given index by summing the values of the relevant nodes.
+-
+- #### Time Complexity:
+	- **Update**: O(log n)
+	- **Query**: O(log n)
+-
+- ```python
+  class FenwickTree:
+      def __init__(self, n):
+          self.n = n
+          self.tree = [0] * (n + 1)
+  
+      def update(self, index, delta):
+          while index <= self.n:
+              self.tree[index] += delta
+              index += index & -index  # Move to the parent node
+  
+      def query(self, index):
+          sum = 0
+          while index > 0:
+              sum += self.tree[index]
+              index -= index & -index  # Move to the parent node
+          return sum
+  
+  # Example usage
+  fenwick = FenwickTree(5)
+  fenwick.update(1, 3)
+  fenwick.update(3, 5)
+  
+  print(f"Sum of first 3 elements: {fenwick.query(3)}")  # Output: 8
+  print(f"Sum of first 5 elements: {fenwick.query(5)}")  # Output: 8
+  ```

pages/Binary Search.md

@@ -0,0 +1,47 @@
+# Explanation
+	- Binary Search is an efficient algorithm used to find an element in a sorted list or array. It works by dividing the list into two halves and repeatedly narrowing down the search space until the target element is found.
+-
+- # Steps:
+	- The **list must be sorted** first.
+	- Start with the low pointer at index 0 and the high pointer at the last index of the list.
+	-
+	- Find the middle element: `mid = (low + high) // 2`.
+	-
+	- **Compare the middle element** with the target:
+		- If the middle element is equal to the target, return the index.
+		-
+		- If the middle element is greater than the target, the target must be in the left half, so set `high = mid - 1`.
+		-
+		- If the middle element is smaller than the target, the target must be in the right half, so set `low = mid + 1`.
+		-
+	- This process repeats until the target element is found or the search space is exhausted.
+-
+- # Time Complexity:
+	- The time complexity of Binary Search is **O(log n)**, where **n** is the number of elements in the list or array.
+-
+- ```python
+  def binary_search(arr, target):
+      low = 0
+      high = len(arr) - 1
+  
+      while low <= high:
+          mid = (low + high) // 2  # Find middle index
+          if arr[mid] == target:   # Target found
+              return mid
+          elif arr[mid] < target:  # Target is in the right half
+              low = mid + 1
+          else:                    # Target is in the left half
+              high = mid - 1
+  
+      return -1  # Target not found
+  
+  # Example usage
+  arr = [1, 3, 5, 7, 9, 11, 13]
+  target = 9
+  result = binary_search(arr, target)
+  
+  if result != -1:
+      print(f"Element found at index {result}")
+  else:
+      print("Element not found")
+  ```

pages/Binary Space Partitioning.md

@@ -0,0 +1,33 @@
+#### Explanation:
+	- **Binary Space Partitioning** is a technique used for recursively dividing a space into two half-spaces by hyperplanes (lines in 2D, planes in 3D).
+	-
+	- It is used in **computer graphics**, **collision detection**, and **ray tracing**.
+-
+- #### Steps:
+	- The space is recursively divided by choosing hyperplanes (like splitting a 2D plane into two parts).
+	-
+	- BSP trees store this hierarchical structure, which can be traversed for efficient querying of the space.
+-
+- #### Time Complexity:
+	- **Insertion**: O(log n)
+	- **Querying**: O(log n) for spatial queries.
+-
+- ```python
+  class BSPTreeNode:
+      def __init__(self, partition_plane=None):
+          self.partition_plane = partition_plane
+          self.front = None
+          self.back = None
+  
+  class BSPTree:
+      def __init__(self):
+          self.root = None
+      
+      def insert(self, partition_plane):
+          # Insert partition and construct BSP tree
+          pass
+  
+  # Example usage
+  bsp_tree = BSPTree()
+  bsp_tree.insert("partition1")
+  ```