Added the dsa Programs to the project

Author: gunjan-ghangare

dsa_programs/README.md

@@ -0,0 +1,35 @@
+# DSA Programs
+
+Thirty standalone algorithm examples, surfaced from the package root:
+
+- `two_sum.py` – hash map pair finder in linear time.
+- `binary_search.py` – iterative search on sorted sequences.
+- `merge_sort.py` – stable divide-and-conquer sort.
+- `quick_select.py` – k-th statistic selection in expected linear time.
+- `breadth_first_search.py` – queue-based graph traversal.
+- `depth_first_search.py` – recursive graph exploration.
+- `topological_sort.py` – Kahn's algorithm for DAG ordering.
+- `dijkstra_shortest_path.py` – priority-queue shortest paths.
+- `lru_cache.py` – ordered dictionary backed LRU cache.
+- `knapsack_01.py` – 0/1 knapsack dynamic program.
+- `bellman_ford.py` – edge relaxation with negative-cycle detection.
+- `floyd_warshall.py` – all-pairs shortest paths on dense graphs.
+- `prim_mst.py` – minimum spanning tree via Prim's algorithm.
+- `kruskal_mst.py` – MST construction with union-find.
+- `union_find.py` – disjoint-set data structure.
+- `segment_tree.py` – range-sum queries with point updates.
+- `fenwick_tree.py` – binary indexed tree for prefix sums.
+- `trie.py` – prefix tree with search and prefix checks.
+- `boyer_moore_majority.py` – majority element by voting.
+- `kadane_max_subarray.py` – maximum subarray sum in linear time.
+- `dutch_national_flag.py` – three-way partition of 0/1/2 values.
+- `heap_sort.py` – heap-based in-place sorting.
+- `sieve_of_eratosthenes.py` – prime number generation.
+- `reservoir_sampling.py` – uniform streaming sample of size k.
+- `sliding_window_maximum.py` – deque based sliding extrema.
+- `rabin_karp.py` – rolling hash substring search.
+- `kmp_search.py` – prefix-function substring search.
+- `manacher_palindrome.py` – longest palindromic substring in linear time.
+- `edit_distance.py` – Levenshtein distance dynamic program.
+- `longest_common_subsequence.py` – subsequence reconstruction DP.
+- `tarjan_scc.py` – strongly connected components in directed graphs.

dsa_programs/__init__.py

@@ -0,0 +1,67 @@
+"""Core data structures and algorithms examples for quick reference."""
+
+from .bellman_ford import bellman_ford
+from .binary_search import binary_search
+from .boyer_moore_majority import boyer_moore_majority
+from .breadth_first_search import breadth_first_search
+from .depth_first_search import depth_first_search
+from .dijkstra_shortest_path import dijkstra_shortest_path
+from .dutch_national_flag import dutch_national_flag
+from .edit_distance import edit_distance
+from .fenwick_tree import FenwickTree
+from .floyd_warshall import floyd_warshall
+from .heap_sort import heap_sort
+from .kadane_max_subarray import kadane_max_subarray
+from .knapsack_01 import knapsack_01
+from .kruskal_mst import kruskal_mst
+from .longest_common_subsequence import longest_common_subsequence
+from .lru_cache import LRUCache
+from .manacher_palindrome import manacher_longest_palindrome
+from .merge_sort import merge_sort
+from .prim_mst import prim_mst
+from .quick_select import quick_select
+from .kmp_search import kmp_search
+from .rabin_karp import rabin_karp_search
+from .reservoir_sampling import reservoir_sample
+from .segment_tree import SegmentTree
+from .sieve_of_eratosthenes import sieve_of_eratosthenes
+from .sliding_window_maximum import sliding_window_maximum
+from .tarjan_scc import tarjan_strongly_connected_components
+from .topological_sort import topological_sort
+from .trie import Trie
+from .two_sum import two_sum
+from .union_find import UnionFind
+
+__all__ = [
+    "FenwickTree",
+    "LRUCache",
+    "SegmentTree",
+    "Trie",
+    "UnionFind",
+    "bellman_ford",
+    "binary_search",
+    "boyer_moore_majority",
+    "breadth_first_search",
+    "depth_first_search",
+    "dijkstra_shortest_path",
+    "dutch_national_flag",
+    "edit_distance",
+    "floyd_warshall",
+    "heap_sort",
+    "kadane_max_subarray",
+    "kmp_search",
+    "knapsack_01",
+    "kruskal_mst",
+    "longest_common_subsequence",
+    "manacher_longest_palindrome",
+    "merge_sort",
+    "prim_mst",
+    "quick_select",
+    "rabin_karp_search",
+    "reservoir_sample",
+    "sieve_of_eratosthenes",
+    "sliding_window_maximum",
+    "tarjan_strongly_connected_components",
+    "topological_sort",
+    "two_sum",
+]

dsa_programs/bellman_ford.py

@@ -0,0 +1,29 @@
+"""Bellman-Ford shortest paths with negative cycle detection."""
+
+from typing import Dict, Iterable, List, Set, Tuple, TypeVar
+
+T = TypeVar("T")
+Edge = Tuple[T, T, float]
+
+
+def bellman_ford(vertices: Iterable[T], edges: Iterable[Edge], source: T) -> Dict[T, float]:
+    edge_list: List[Edge] = list(edges)
+    vertex_set: Set[T] = set(vertices)
+    for u, v, _ in edge_list:
+        vertex_set.add(u)
+        vertex_set.add(v)
+    vertex_set.add(source)
+    distances: Dict[T, float] = {vertex: float("inf") for vertex in vertex_set}
+    distances[source] = 0.0
+    for _ in range(len(vertex_set) - 1):
+        updated = False
+        for u, v, weight in edge_list:
+            if distances[u] + weight < distances[v]:
+                distances[v] = distances[u] + weight
+                updated = True
+        if not updated:
+            break
+    for u, v, weight in edge_list:
+        if distances[u] + weight < distances[v]:
+            raise ValueError("Graph contains a negative-weight cycle")
+    return distances

dsa_programs/binary_search.py

@@ -0,0 +1,17 @@
+"""Iterative binary search on a sorted sequence."""
+
+from typing import Sequence
+
+
+def binary_search(items: Sequence[int], target: int) -> int:
+    left, right = 0, len(items) - 1
+    while left <= right:
+        mid = (left + right) // 2
+        value = items[mid]
+        if value == target:
+            return mid
+        if value < target:
+            left = mid + 1
+        else:
+            right = mid - 1
+    return -1

dsa_programs/boyer_moore_majority.py

@@ -0,0 +1,25 @@
+"""Boyer-Moore majority vote algorithm."""
+
+from typing import Iterable, List, TypeVar
+
+T = TypeVar("T")
+
+
+def boyer_moore_majority(items: Iterable[T]) -> T:
+    data: List[T] = list(items)
+    if not data:
+        raise ValueError("Sequence is empty")
+    candidate: T | None = None
+    count = 0
+    for value in data:
+        if count == 0:
+            candidate = value
+            count = 1
+        elif value == candidate:
+            count += 1
+        else:
+            count -= 1
+    assert candidate is not None  # mypy helper
+    if data.count(candidate) <= len(data) // 2:
+        raise ValueError("No majority element present")
+    return candidate

dsa_programs/breadth_first_search.py

@@ -0,0 +1,21 @@
+"""Breadth-first search returning discovery order from a starting node."""
+
+from collections import deque
+from typing import Deque, Dict, Iterable, List, Set, TypeVar
+
+T = TypeVar("T")
+
+
+def breadth_first_search(graph: Dict[T, Iterable[T]], start: T) -> List[T]:
+    visited: Set[T] = set()
+    order: List[T] = []
+    queue: Deque[T] = deque([start])
+    visited.add(start)
+    while queue:
+        node = queue.popleft()
+        order.append(node)
+        for neighbor in graph.get(node, ()):  # gracefully handle missing keys
+            if neighbor not in visited:
+                visited.add(neighbor)
+                queue.append(neighbor)
+    return order

dsa_programs/depth_first_search.py

@@ -0,0 +1,20 @@
+"""Depth-first search using recursion to record visitation order."""
+
+from typing import Dict, Iterable, List, Set, TypeVar
+
+T = TypeVar("T")
+
+
+def depth_first_search(graph: Dict[T, Iterable[T]], start: T) -> List[T]:
+    visited: Set[T] = set()
+    order: List[T] = []
+
+    def _dfs(node: T) -> None:
+        visited.add(node)
+        order.append(node)
+        for neighbor in graph.get(node, ()):  # support sparse adjacency
+            if neighbor not in visited:
+                _dfs(neighbor)
+
+    _dfs(start)
+    return order

dsa_programs/dijkstra_shortest_path.py

@@ -0,0 +1,23 @@
+"""Dijkstra's shortest path algorithm with a min-heap."""
+
+from heapq import heappop, heappush
+from typing import Dict, Iterable, List, Tuple, TypeVar
+
+T = TypeVar("T")
+
+Graph = Dict[T, Iterable[Tuple[T, float]]]
+
+
+def dijkstra_shortest_path(graph: Graph, source: T) -> Dict[T, float]:
+    distances: Dict[T, float] = {source: 0.0}
+    heap: List[Tuple[float, T]] = [(0.0, source)]
+    while heap:
+        current_dist, node = heappop(heap)
+        if current_dist > distances.get(node, float("inf")):
+            continue
+        for neighbor, weight in graph.get(node, ()):  # missing key means no outgoing edges
+            cost = current_dist + weight
+            if cost < distances.get(neighbor, float("inf")):
+                distances[neighbor] = cost
+                heappush(heap, (cost, neighbor))
+    return distances

dsa_programs/dutch_national_flag.py

@@ -0,0 +1,21 @@
+"""In-place Dutch national flag partitioning for values 0, 1, and 2."""
+
+from typing import MutableSequence
+
+
+def dutch_national_flag(items: MutableSequence[int]) -> None:
+    low = mid = 0
+    high = len(items) - 1
+    while mid <= high:
+        value = items[mid]
+        if value == 0:
+            items[low], items[mid] = items[mid], items[low]
+            low += 1
+            mid += 1
+        elif value == 1:
+            mid += 1
+        elif value == 2:
+            items[mid], items[high] = items[high], items[mid]
+            high -= 1
+        else:
+            raise ValueError("Items must be 0, 1, or 2 only")

dsa_programs/edit_distance.py

@@ -0,0 +1,30 @@
+"""Levenshtein edit distance via dynamic programming."""
+
+from typing import Sequence
+
+
+def edit_distance(a: Sequence[str], b: Sequence[str]) -> int:
+    if isinstance(a, str):
+        seq_a = list(a)
+    else:
+        seq_a = list(a)
+    if isinstance(b, str):
+        seq_b = list(b)
+    else:
+        seq_b = list(b)
+    m = len(seq_a)
+    n = len(seq_b)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+    for i in range(m + 1):
+        dp[i][0] = i
+    for j in range(n + 1):
+        dp[0][j] = j
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            cost = 0 if seq_a[i - 1] == seq_b[j - 1] else 1
+            dp[i][j] = min(
+                dp[i - 1][j] + 1,
+                dp[i][j - 1] + 1,
+                dp[i - 1][j - 1] + cost,
+            )
+    return dp[m][n]