Refactoring (TheAlgorithms#4146)

ishhan · web-flow · commit 0c618b5ee806 · 2023-04-14T08:34:47.000Z
diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/HamiltonianCycle.java b/src/main/java/com/thealgorithms/datastructures/graphs/HamiltonianCycle.java
@@ -47,7 +47,8 @@ public int[] findHamiltonianCycle(int[][] graph) {
      * @returns true if path is found false otherwise
      */
     public boolean isPathFound(int vertex) {
-        if (this.graph[vertex][0] == 1 && this.pathCount == this.V) {
+        boolean isLastVertexConnectedToStart = this.graph[vertex][0] == 1 && this.pathCount == this.V;
+        if (isLastVertexConnectedToStart) {
             return true;
         }
 
diff --git a/src/main/java/com/thealgorithms/datastructures/trees/CheckTreeIsSymmetric.java b/src/main/java/com/thealgorithms/datastructures/trees/CheckTreeIsSymmetric.java
@@ -44,10 +44,14 @@ private static boolean isSymmetric(Node leftSubtreeRoot, Node rightSubtreRoot) {
             return true;
         }
 
-        if (leftSubtreeRoot == null || rightSubtreRoot == null || leftSubtreeRoot.data != rightSubtreRoot.data) {
+        if (isInvalidSubtree(leftSubtreeRoot, rightSubtreRoot)) {
             return false;
         }
 
         return isSymmetric(leftSubtreeRoot.right, rightSubtreRoot.left) && isSymmetric(leftSubtreeRoot.left, rightSubtreRoot.right);
     }
+
+    private static boolean isInvalidSubtree(Node leftSubtreeRoot, Node rightSubtreeRoot) {
+        return leftSubtreeRoot == null || rightSubtreeRoot == null || leftSubtreeRoot.data != rightSubtreeRoot.data;
+    }
 }
diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/KnapsackMemoization.java b/src/main/java/com/thealgorithms/dynamicprogramming/KnapsackMemoization.java
@@ -9,44 +9,43 @@
  */
 public class KnapsackMemoization {
 
-    int knapSack(int W, int wt[], int val[], int N) {
+    int knapSack(int capacity, int[] weights, int[] profits, int numOfItems) {
 
         // Declare the table dynamically
-        int dp[][] = new int[N + 1][W + 1];
+        int[][] dpTable = new int[numOfItems + 1][capacity + 1];
 
-        // Loop to initially filled the
-        // table with -1
-        for (int i = 0; i < N + 1; i++) {
-            for (int j = 0; j < W + 1; j++) {
-                dp[i][j] = -1;
+        // Loop to initially fill the table with -1
+        for (int i = 0; i < numOfItems + 1; i++) {
+            for (int j = 0; j < capacity + 1; j++) {
+                dpTable[i][j] = -1;
             }
         }
 
-        return knapSackRec(W, wt, val, N, dp);
+        return solveKnapsackRecursive(capacity, weights, profits, numOfItems, dpTable);
     }
 
-    // Returns the value of maximum profit using Recursive approach
-    int knapSackRec(int W, int wt[],
-            int val[], int n,
-            int[][] dp) {
+    // Returns the value of maximum profit using recursive approach
+    int solveKnapsackRecursive(int capacity, int[] weights,
+            int[] profits, int numOfItems,
+            int[][] dpTable) {
 
         // Base condition
-        if (n == 0 || W == 0) {
+        if (numOfItems == 0 || capacity == 0) {
             return 0;
         }
 
-        if (dp[n][W] != -1) {
-            return dp[n][W];
+        if (dpTable[numOfItems][capacity] != -1) {
+            return dpTable[numOfItems][capacity];
         }
 
-        if (wt[n - 1] > W) {
+        if (weights[numOfItems - 1] > capacity) {
             // Store the value of function call stack in table
-            dp[n][W] = knapSackRec(W, wt, val, n - 1, dp);
-            return dp[n][W];
+            dpTable[numOfItems][capacity] = solveKnapsackRecursive(capacity, weights, profits, numOfItems - 1, dpTable);
+            return dpTable[numOfItems][capacity];
         } else {
             // Return value of table after storing
-            return dp[n][W] = Math.max((val[n - 1] + knapSackRec(W - wt[n - 1], wt, val, n - 1, dp)),
-                    knapSackRec(W, wt, val, n - 1, dp));
+            return dpTable[numOfItems][capacity] = Math.max((profits[numOfItems - 1] + solveKnapsackRecursive(capacity - weights[numOfItems - 1], weights, profits, numOfItems - 1, dpTable)),
+                    solveKnapsackRecursive(capacity, weights, profits, numOfItems - 1, dpTable));
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,8 @@ public int[] findHamiltonianCycle(int[][] graph) {`
`47`	`47`	`* @returns true if path is found false otherwise`
`48`	`48`	`*/`
`49`	`49`	`public boolean isPathFound(int vertex) {`
`50`		`- if (this.graph[vertex][0] == 1 && this.pathCount == this.V) {`
	`50`	`+ boolean isLastVertexConnectedToStart = this.graph[vertex][0] == 1 && this.pathCount == this.V;`
	`51`	`+ if (isLastVertexConnectedToStart) {`
`51`	`52`	`return true;`
`52`	`53`	`}`
`53`	`54`
Original file line number	Diff line number	Diff line change
`@@ -44,10 +44,14 @@ private static boolean isSymmetric(Node leftSubtreeRoot, Node rightSubtreRoot) {`
`44`	`44`	`return true;`
`45`	`45`	`}`
`46`	`46`
`47`		`- if (leftSubtreeRoot == null \|\| rightSubtreRoot == null \|\| leftSubtreeRoot.data != rightSubtreRoot.data) {`
	`47`	`+ if (isInvalidSubtree(leftSubtreeRoot, rightSubtreRoot)) {`
`48`	`48`	`return false;`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`return isSymmetric(leftSubtreeRoot.right, rightSubtreRoot.left) && isSymmetric(leftSubtreeRoot.left, rightSubtreRoot.right);`
`52`	`52`	`}`
	`53`	`+`
	`54`	`+ private static boolean isInvalidSubtree(Node leftSubtreeRoot, Node rightSubtreeRoot) {`
	`55`	`+ return leftSubtreeRoot == null \|\| rightSubtreeRoot == null \|\| leftSubtreeRoot.data != rightSubtreeRoot.data;`
	`56`	`+ }`
`53`	`57`	`}`