feat: Add topological sort and disjoint set algorithms

Author: Siddhram

graph_algorithms/disjoint_set.r

@@ -0,0 +1,118 @@
+# Disjoint Set Union (Union-Find)
+#
+# A data structure that keeps track of elements partitioned into disjoint sets.
+# Supports union and find operations efficiently using path compression and union by rank.
+#
+# Time Complexity: Nearly O(1) per operation (amortized with path compression)
+# Space Complexity: O(N)
+#
+# Applications:
+# - Detecting cycles in undirected graphs
+# - Kruskal's MST algorithm
+# - Network connectivity
+# - Social network grouping
+# - Image segmentation
+# - Connected components in graphs
+
+make_set <- function(n) {
+  #' Initialize disjoint set with n elements
+  #' @param n: Number of elements (0 to n-1)
+  #' @return: List containing parent array and rank array
+  
+  # Each element is initially its own parent
+  parent <- 0:(n-1)
+  # Initial rank (tree height) is 0 for all elements
+  rank <- rep(0, n)
+  
+  list(parent = parent, rank = rank)
+}
+
+find_set <- function(ds, v) {
+  #' Find the representative (root) of the set containing v
+  #' Uses path compression for efficiency
+  #' @param ds: Disjoint set data structure
+  #' @param v: Element to find
+  #' @return: Representative of v's set
+  
+  if (ds$parent[v + 1] != v) {
+    # Path compression: Make all nodes on path point to root
+    ds$parent[v + 1] <- find_set(ds, ds$parent[v + 1])
+  }
+  ds$parent[v + 1]
+}
+
+union_sets <- function(ds, a, b) {
+  #' Union two sets by rank
+  #' @param ds: Disjoint set data structure
+  #' @param a: First element
+  #' @param b: Second element
+  #' @return: Updated disjoint set structure
+  
+  a_root <- find_set(ds, a)
+  b_root <- find_set(ds, b)
+  
+  if (a_root != b_root) {
+    # Union by rank: Attach smaller rank tree under root of higher rank tree
+    if (ds$rank[a_root + 1] < ds$rank[b_root + 1]) {
+      # Swap to ensure a_root has higher rank
+      temp <- a_root
+      a_root <- b_root
+      b_root <- temp
+    }
+    
+    ds$parent[b_root + 1] <- a_root
+    
+    # If ranks are equal, increment the rank of the root
+    if (ds$rank[a_root + 1] == ds$rank[b_root + 1]) {
+      ds$rank[a_root + 1] <- ds$rank[a_root + 1] + 1
+    }
+  }
+  
+  return(ds)
+}
+
+# Example Usage
+# Test case 1: Basic operations
+cat("=== Test Case 1: Basic Union-Find Operations ===\n")
+ds1 <- make_set(5)  # Create sets for elements 0-4
+cat("Initial parents:", paste(ds1$parent, collapse = " "), "\n")
+
+ds1 <- union_sets(ds1, 0, 1)  # Union first two elements
+ds1 <- union_sets(ds1, 2, 3)  # Union next two elements
+cat("After unions:", paste(ds1$parent, collapse = " "), "\n")
+
+cat("Find(1):", find_set(ds1, 1), "\n")
+cat("Find(2):", find_set(ds1, 2), "\n")
+
+# Test case 2: Path compression
+cat("\n=== Test Case 2: Path Compression ===\n")
+ds2 <- make_set(6)
+ds2 <- union_sets(ds2, 0, 1)
+ds2 <- union_sets(ds2, 1, 2)
+ds2 <- union_sets(ds2, 2, 3)
+cat("Parents before find:", paste(ds2$parent, collapse = " "), "\n")
+find_set(ds2, 3)  # This should compress the path
+cat("Parents after find:", paste(ds2$parent, collapse = " "), "\n")
+
+# Test case 3: Connected components
+cat("\n=== Test Case 3: Finding Connected Components ===\n")
+ds3 <- make_set(7)
+edges <- list(c(0,1), c(1,2), c(3,4), c(5,6))
+for (edge in edges) {
+  ds3 <- union_sets(ds3, edge[1], edge[2])
+}
+
+# Print connected components
+components <- list()
+for (i in 0:6) {
+  root <- find_set(ds3, i)
+  if (is.null(components[[as.character(root)]])) {
+    components[[as.character(root)]] <- c()
+  }
+  components[[as.character(root)]] <- c(components[[as.character(root)]], i)
+}
+
+cat("Connected Components:\n")
+for (comp in components) {
+  cat("  Group:", paste(comp, collapse = " "), "\n")
+}

graph_algorithms/topological_sort.r

@@ -0,0 +1,91 @@
+# Topological Sort (Kahn's Algorithm)
+#
+# The topological sort of a directed acyclic graph (DAG) is a linear ordering 
+# of vertices such that for every directed edge u -> v, vertex u comes before v.
+#
+# Time Complexity: O(V + E)
+# Space Complexity: O(V)
+#
+# Applications:
+# - Task scheduling and dependency resolution
+# - Build systems (compilation order)
+# - Job scheduling in distributed systems
+# - Resolving package dependencies
+
+topological_sort <- function(V, edges) {
+  #' Perform topological sorting on a DAG
+  #' @param V: Number of vertices (0 to V-1)
+  #' @param edges: List of edge pairs (u, v)
+  #' @return: Topologically sorted order or NULL if cycle exists
+  
+  adj <- vector("list", V)
+  indegree <- rep(0, V)
+  
+  # Build adjacency list and calculate in-degrees
+  for (e in edges) {
+    u <- e[1]
+    v <- e[2]
+    adj[[u]] <- c(adj[[u]], v)
+    indegree[v] <- indegree[v] + 1
+  }
+  
+  # Initialize queue with vertices having no incoming edges
+  q <- which(indegree == 0)
+  topo <- c()
+  
+  # Process vertices in topological order
+  while (length(q) > 0) {
+    node <- q[1]
+    q <- q[-1]
+    topo <- c(topo, node)
+    
+    # Update in-degrees of neighbors
+    for (nbr in adj[[node]]) {
+      indegree[nbr] <- indegree[nbr] - 1
+      if (indegree[nbr] == 0) {
+        q <- c(q, nbr)  # Add to queue when in-degree becomes 0
+      }
+    }
+  }
+  
+  # Check if valid topological sort exists
+  if (length(topo) == V) {
+    return(topo)
+  } else {
+    return(NULL)  # Cycle detected
+  }
+}
+
+# Example Usage
+# Test case 1: Simple DAG
+cat("=== Test Case 1: Simple DAG ===\n")
+V1 <- 4
+edges1 <- list(c(0,1), c(0,2), c(2,3), c(1,3))
+result1 <- topological_sort(V1, edges1)
+if (!is.null(result1)) {
+  cat("Topological Order:", paste(result1, collapse = " -> "), "\n")
+} else {
+  cat("Graph contains a cycle!\n")
+}
+
+# Test case 2: Larger DAG
+cat("\n=== Test Case 2: Larger DAG ===\n")
+V2 <- 6
+edges2 <- list(c(5,2), c(5,0), c(4,0), c(4,1), c(2,3), c(3,1))
+result2 <- topological_sort(V2, edges2)
+if (!is.null(result2)) {
+  cat("Topological Order:", paste(result2, collapse = " -> "), "\n")
+} else {
+  cat("Graph contains a cycle!\n")
+}
+
+# Test case 3: Graph with cycle
+cat("\n=== Test Case 3: Graph with Cycle ===\n")
+V3 <- 3
+edges3 <- list(c(0,1), c(1,2), c(2,0))  # Cycle: 0->1->2->0
+result3 <- topological_sort(V3, edges3)
+if (!is.null(result3)) {
+  cat("Topological Order:", paste(result3, collapse = " -> "), "\n")
+} else {
+  cat("Graph contains a cycle!\n")
+}