Merge branch 'main' into main

Author: adityacosmos24

README.md

@@ -52,8 +52,6 @@ Visualize how algorithms explore and find paths across a grid.
 - Depth First Search (DFS)  
 - Dijkstra’s Algorithm  
 - A* Search  
-- Greedy Best-First Search  
-- Bellman-Ford  
 
 **Interactive Options:**
 - Set start and end points  

public/graph.png

@@ -1,17 +1,21 @@
 import React from "react";
 import { BrowserRouter as Router, Routes, Route } from "react-router-dom";
-import Homepage from "./pages/Homepage";
+// import UnionFindPage from "../src/pages/graph/UnionFind.jsx"; // ✅ Import Union-Find Page
 import SortingPage from "./pages/sorting/SortingPage";
+import GraphPage from "./pages/graph/GraphPage";
+import Homepage from "./pages/Homepage.jsx";
 
 function App() {
   return (
     <Router>
       <Routes>
         <Route path="/" element={<Homepage />} />
+        {/* <Route path="/graph/union-find" element={<UnionFindPage />} /> */}
         <Route path="/sorting" element={<SortingPage />} />
+        <Route path="/graph" element={<GraphPage />} />
       </Routes>
     </Router>
   );
 }
 
-export default App;
+export default App;

src/App.jsx

@@ -0,0 +1,37 @@
+export default function runBellmanFord(nodes, edges, source) {
+  const dist = {};
+  nodes.forEach(n => dist[n] = Infinity);
+  dist[source] = 0;
+
+  const steps = [];
+
+  // Relax edges |V|-1 times
+  for (let i = 0; i < nodes.length - 1; i++) {
+    for (const edge of edges) {
+      const { from, to, weight } = edge;
+      const step = {
+        type: "relax",
+        iteration: i + 1,
+        edge,
+        prevDistance: dist[to]
+      };
+
+      if (dist[from] + weight < dist[to]) {
+        dist[to] = dist[from] + weight;
+        step.updatedDistance = dist[to];
+      }
+
+      steps.push(step);
+    }
+  }
+
+  // Check for negative weight cycles
+  for (const edge of edges) {
+    const { from, to, weight } = edge;
+    if (dist[from] + weight < dist[to]) {
+      steps.push({ type: "negativeCycle", edge });
+    }
+  }
+
+  return steps;
+}

src/algorithms/graph/bellmanFord.js

@@ -0,0 +1,54 @@
+// src/algorithms/graph/kruskal.js
+
+class DSU {
+  constructor(n) {
+    this.parent = Array.from({ length: n }, (_, i) => i);
+    this.rank = Array(n).fill(0);
+  }
+
+  find(x) {
+    if (this.parent[x] !== x) {
+      this.parent[x] = this.find(this.parent[x]);
+    }
+    return this.parent[x];
+  }
+
+  union(x, y) {
+    const rx = this.find(x);
+    const ry = this.find(y);
+    if (rx === ry) return false;
+
+    if (this.rank[rx] < this.rank[ry]) this.parent[rx] = ry;
+    else if (this.rank[rx] > this.rank[ry]) this.parent[ry] = rx;
+    else {
+      this.parent[ry] = rx;
+      this.rank[rx]++;
+    }
+    return true;
+  }
+
+  getState() {
+    return [...this.parent];
+  }
+}
+
+// 🧠 Generator that yields every visualization step
+export function* kruskalSteps(edges, nodeCount) {
+  const sortedEdges = [...edges].sort((a, b) => a.weight - b.weight);
+  const dsu = new DSU(nodeCount);
+  const mst = [];
+
+  for (let edge of sortedEdges) {
+    yield { type: "consider", edge, dsu: dsu.getState() };
+
+    const merged = dsu.union(edge.from - 1, edge.to - 1);
+    if (merged) {
+      mst.push(edge);
+      yield { type: "add", edge, mst: [...mst], dsu: dsu.getState() };
+    } else {
+      yield { type: "skip", edge, dsu: dsu.getState() };
+    }
+  }
+
+  yield { type: "done", mst, dsu: dsu.getState() };
+}

src/algorithms/graph/kruskal.js

@@ -0,0 +1,72 @@
+// src/algorithms/graph/unionFind.js
+
+class UnionFind {
+  constructor(n) {
+    this.parent = Array.from({ length: n }, (_, i) => i);
+    this.rank = Array(n).fill(0);
+    this.steps = []; // For visualization steps
+  }
+
+  find(x) {
+    this.steps.push({ type: "find-start", node: x });
+    if (this.parent[x] !== x) {
+      const root = this.find(this.parent[x]);
+      this.steps.push({
+        type: "path-compression",
+        node: x,
+        newParent: root,
+      });
+      this.parent[x] = root;
+    }
+    this.steps.push({ type: "find-end", node: x, root: this.parent[x] });
+    return this.parent[x];
+  }
+
+  union(x, y) {
+    const rootX = this.find(x);
+    const rootY = this.find(y);
+
+    this.steps.push({
+      type: "union-start",
+      x,
+      y,
+      rootX,
+      rootY,
+    });
+
+    if (rootX === rootY) {
+      this.steps.push({ type: "same-set", x, y });
+      return;
+    }
+
+    if (this.rank[rootX] < this.rank[rootY]) {
+      this.parent[rootX] = rootY;
+      this.steps.push({
+        type: "union",
+        parent: rootY,
+        child: rootX,
+      });
+    } else if (this.rank[rootX] > this.rank[rootY]) {
+      this.parent[rootY] = rootX;
+      this.steps.push({
+        type: "union",
+        parent: rootX,
+        child: rootY,
+      });
+    } else {
+      this.parent[rootY] = rootX;
+      this.rank[rootX]++;
+      this.steps.push({
+        type: "union-rank",
+        parent: rootX,
+        child: rootY,
+      });
+    }
+  }
+
+  getSteps() {
+    return this.steps;
+  }
+}
+
+export default UnionFind;

src/algorithms/graph/unionFind.js

@@ -0,0 +1,64 @@
+// src/algorithms/sorting/mergeSort.js
+export function* mergeSort(array) {
+  const arr = [...array];
+  const n = arr.length;
+
+  if (n === 0) {
+    yield { type: "done", array: arr };
+    return;
+  }
+
+  function* merge(l, m, r) {
+    const left = arr.slice(l, m + 1);
+    const right = arr.slice(m + 1, r + 1);
+    let i = 0;
+    let j = 0;
+    let k = l;
+
+    while (i < left.length && j < right.length) {
+      // highlight the two elements being compared (use their original indices)
+      yield { type: "compare", indices: [l + i, m + 1 + j] };
+
+      if (left[i] <= right[j]) {
+        arr[k] = left[i];
+        yield { type: "swap", indices: [k, l + i], array: [...arr] };
+        i++;
+      } else {
+        arr[k] = right[j];
+        yield { type: "swap", indices: [k, m + 1 + j], array: [...arr] };
+        j++;
+      }
+      k++;
+    }
+
+    while (i < left.length) {
+      arr[k] = left[i];
+      yield { type: "swap", indices: [k, l + i], array: [...arr] };
+      i++;
+      k++;
+    }
+
+    while (j < right.length) {
+      arr[k] = right[j];
+      yield { type: "swap", indices: [k, m + 1 + j], array: [...arr] };
+      j++;
+      k++;
+    }
+
+    // mark merged positions as "min" to indicate they're in final place for this merge
+    for (let idx = l; idx <= r; idx++) {
+      yield { type: "min", index: idx };
+    }
+  }
+
+  function* mergeSortRec(l, r) {
+    if (l >= r) return;
+    const m = Math.floor((l + r) / 2);
+    yield* mergeSortRec(l, m);
+    yield* mergeSortRec(m + 1, r);
+    yield* merge(l, m, r);
+  }
+
+  yield* mergeSortRec(0, n - 1);
+  yield { type: "done", array: arr };
+}