Added some style issues in articulationpoints.go

Author: mapcrafter2048

graph/articulationpoints.go

@@ -1,61 +1,48 @@
-// articulationpoints.go
-// description: Provides a function to identify articulation points in a graph.
-// time complexity: O(|V| + |E|) where |V| is the number of vertices and |E| is the number of edges in the graph
-// space complexity: O(|V|) where |V| is the number of vertices in the graph
-
+// Package graph provides algorithms to analyze graph structures.
 package graph
 
 import "github.com/TheAlgorithms/Go/math/min"
 
+// apHelper stores auxiliary data used to identify articulation points in a graph.
 type apHelper struct {
-	is_ap              []bool
-	visited            []bool
-	child_cnt          []int
-	discovery_time     []int
-	earliest_discovery []int
+	isAP              []bool
+	visited           []bool
+	childCount        []int
+	discoveryTime     []int
+	earliestDiscovery []int
 }
 
-// ArticulationPoint is a function to identify articulation points in a graph.
-// The function takes the graph as an argument and returns a boolean slice
-// which indicates whether a vertex is an articulation point or not.
+// ArticulationPoint identifies articulation points in a graph. It returns a boolean slice
+// where each element indicates whether a vertex is an articulation point.
 // Worst Case Time Complexity: O(|V| + |E|)
 // Auxiliary Space: O(|V|)
-// reference: https://en.wikipedia.org/wiki/Biconnected_component and https://cptalks.quora.com/Cut-Vertex-Articulation-point
+// Reference: https://en.wikipedia.org/wiki/Biconnected_component and https://cptalks.quora.com/Cut-Vertex-Articulation-point
 func ArticulationPoint(graph *Graph) []bool {
-	// time variable to keep track of the time of discovery_time of a vertex
+	// Time variable to keep track of the discovery time of a vertex
 	time := 0
 
-	//initialize all the variables
+	// Initialize apHelper instance with the required data structures
 	apHelperInstance := &apHelper{
-		is_ap:     make([]bool, graph.vertices),
-		visited:   make([]bool, graph.vertices),
-		child_cnt: make([]int, graph.vertices),
-		// integer slice to store the discovery time of a vertex as we traverse
-		// the graph in a depth first manner
-		discovery_time: make([]int, graph.vertices),
-		// integer slice to store the earliest discovered vertex reachable from a vertex
-		earliest_discovery: make([]int, graph.vertices),
+		isAP:              make([]bool, graph.vertices),
+		visited:           make([]bool, graph.vertices),
+		childCount:        make([]int, graph.vertices),
+		discoveryTime:     make([]int, graph.vertices),
+		earliestDiscovery: make([]int, graph.vertices),
 	}
-	articulationPointHelper(
-		apHelperInstance,
-		0,
-		-1,
-		&time,
-		graph,
-	)
 
-	if apHelperInstance.child_cnt[0] == 1 {
-		// if the root has only one child, it is not an articulation point
-		apHelperInstance.is_ap[0] = false
+	// Start traversal from the root (0)
+	articulationPointHelper(apHelperInstance, 0, -1, &time, graph)
+
+	// Check if the root has only one child, making it non-articulate
+	if apHelperInstance.childCount[0] == 1 {
+		apHelperInstance.isAP[0] = false
 	}
 
-	return apHelperInstance.is_ap
+	return apHelperInstance.isAP
 }
 
-// articulationPointHelper is a recursive function to traverse the graph
-// and mark articulation points. Based on the depth first search transversal
-// of the graph, however modified to keep track and update the
-// `child_cnt`, `discovery_time` and `earliest_discovery` slices defined above
+// articulationPointHelper recursively traverses the graph using DFS and marks articulation points.
+// It updates `childCount`, `discoveryTime`, and `earliestDiscovery` slices for the given vertex.
 func articulationPointHelper(
 	apHelperInstance *apHelper,
 	vertex int,
@@ -65,41 +52,38 @@ func articulationPointHelper(
 ) {
 	apHelperInstance.visited[vertex] = true
 
-	// Mark the time of discovery of a vertex
-	// set the earliest discovery time to the discovered time
-	// increment the time
-	apHelperInstance.discovery_time[vertex] = *time
-	apHelperInstance.earliest_discovery[vertex] = apHelperInstance.discovery_time[vertex]
+	// Set discovery and earliest discovery times for the vertex
+	apHelperInstance.discoveryTime[vertex] = *time
+	apHelperInstance.earliestDiscovery[vertex] = *time
 	*time++
 
-	for next_vertex := range graph.edges[vertex] {
-		if next_vertex == parent {
+	for nextVertex := range graph.edges[vertex] {
+		if nextVertex == parent {
 			continue
 		}
 
-		if apHelperInstance.visited[next_vertex] {
-			apHelperInstance.earliest_discovery[vertex] = min.Int(
-				apHelperInstance.earliest_discovery[vertex],
-				apHelperInstance.discovery_time[next_vertex],
+		if apHelperInstance.visited[nextVertex] {
+			// Update the earliest discovery time to the smallest reachable discovery time
+			apHelperInstance.earliestDiscovery[vertex] = min.Int(
+				apHelperInstance.earliestDiscovery[vertex],
+				apHelperInstance.discoveryTime[nextVertex],
 			)
 			continue
 		}
 
-		apHelperInstance.child_cnt[vertex]++
-		articulationPointHelper(
-			apHelperInstance,
-			next_vertex,
-			vertex,
-			time,
-			graph,
-		)
-		apHelperInstance.earliest_discovery[vertex] = min.Int(
-			apHelperInstance.earliest_discovery[vertex],
-			apHelperInstance.earliest_discovery[next_vertex],
+		// Increment child count and perform recursive traversal for DFS
+		apHelperInstance.childCount[vertex]++
+		articulationPointHelper(apHelperInstance, nextVertex, vertex, time, graph)
+
+		// Update the earliest discovery time post DFS
+		apHelperInstance.earliestDiscovery[vertex] = min.Int(
+			apHelperInstance.earliestDiscovery[vertex],
+			apHelperInstance.earliestDiscovery[nextVertex],
 		)
-		if apHelperInstance.earliest_discovery[next_vertex] >= apHelperInstance.discovery_time[vertex] {
-			apHelperInstance.is_ap[vertex] = true
-		}
 
+		// Mark vertex as articulation point if condition meets
+		if apHelperInstance.earliestDiscovery[nextVertex] >= apHelperInstance.discoveryTime[vertex] {
+			apHelperInstance.isAP[vertex] = true
+		}
 	}
 }