Comments added

Author: mandana-g

02_activities/assignments/assignment_1.ipynb

@@ -94,108 +94,124 @@
    "source": [
     "# Definition for a binary tree node.\n",
     "class TreeNode(object):\n",
-    "    def __init__(self, val = 0, left = None, right = None):\n",
+    "    def __init__(self, val=0, left=None, right=None):\n",
     "        self.val = val\n",
     "        self.left = left\n",
     "        self.right = right\n",
     "\n",
-    "# Building the tree(DFS-pre-order)\n",
+    "# Building the tree(DFS_pre-order)\n",
     "def build_tree(roots):\n",
     "    if not roots:\n",
     "        return None\n",
-    "    \n",
+    "\n",
     "    root = TreeNode(roots[0])\n",
     "    built_tree = [root]\n",
     "    index = 1\n",
-    "    \n",
+    "\n",
     "    while built_tree and index < len(roots):\n",
     "        node = built_tree.pop(0)\n",
-    "        \n",
+    "\n",
     "        if index < len(roots) and roots[index] is not None:\n",
     "            node.left = TreeNode(roots[index])\n",
     "            built_tree.append(node.left)\n",
     "        index += 1\n",
-    "        \n",
+    "\n",
     "        if index < len(roots) and roots[index] is not None:\n",
     "            node.right = TreeNode(roots[index])\n",
     "            built_tree.append(node.right)\n",
     "        index += 1\n",
-    "    \n",
+    "\n",
     "    return root\n",
     "\n",
-    "def dfs(node, depth, visited):\n",
+    "# DFS function to find duplicates and their depths\n",
+    "def dfs(node, depth, visited, closest_duplicate, min_depth):\n",
     "    if node is None:\n",
-    "        return None, float('inf')  # No duplicate, infinite depth\n",
-    "\n",
-    "    # If the node's value has already been visited, it's a duplicate\n",
+    "        return closest_duplicate, min_depth  # No duplicates found in this path\n",
+    "    \n",
     "    if node.val in visited:\n",
-    "        return node.val, depth  # Found a duplicate at this depth\n",
+    "        if depth < min_depth:\n",
+    "            closest_duplicate = node.val\n",
+    "            min_depth = depth\n",
     "    \n",
     "    visited.add(node.val)\n",
     "\n",
-    "    # Recurse on left and right children and return the closest duplicate\n",
-    "    left_val, left_depth = dfs(node.left, depth + 1, visited)\n",
-    "    right_val, right_depth = dfs(node.right, depth + 1, visited)\n",
+    "    closest_duplicate, min_depth = dfs(node.left, depth + 1, visited, closest_duplicate, min_depth)\n",
+    "    closest_duplicate, min_depth = dfs(node.right, depth + 1, visited, closest_duplicate, min_depth)\n",
     "\n",
-    "    # Compare which duplicate is closer to the root\n",
-    "    if left_depth < right_depth:\n",
-    "        return left_val, left_depth\n",
-    "    else:\n",
-    "        return right_val, right_depth\n",
+    "    return closest_duplicate, min_depth\n",
     "\n",
     "\n",
+    "# Function to find the duplicate with the smallest depth (closest to the root)\n",
     "def find_duplicate(root):\n",
-    "    visited = set()  # To track visited node values\n",
-    "    closest_duplicate, min_depth = dfs(root, 0, visited)\n",
-    "    \n",
-    "    # Return the closest duplicate if found, otherwise return -1\n",
-    "    return closest_duplicate if closest_duplicate is not None else -1\n",
-    "\n"
+    "    visited = set()  \n",
+    "    closest_duplicate, min_depth = dfs(root, 0, visited, None, float('inf')) # setting root as the node(depth 0),closest_duplicate as None, and min_depth as infinite as everything will be less than that\n",
+    "\n",
+    "    return closest_duplicate if closest_duplicate is not None else -1\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Duplicate value: 2\n"
+      "Duplicate value: -1\n"
      ]
     }
    ],
    "source": [
-    "example_roots = [1, 2, 2, 3, 5, 6, 7]   # Testing the example 1\n",
+    "example_roots = [1, 2, 2, 3, 5, 6, 7]   # Testing example 1\n",
     "root = build_tree(example_roots)\n",
     "duplicate = find_duplicate(root)\n",
     "print(f\"Duplicate value: {duplicate}\") "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Duplicate value: 12\n"
+      "Duplicate value: 10\n"
+     ]
+    }
+   ],
+   "source": [
+    "example_roots = [1, 10, 2, 3, 10, 12, 12]   # Testing example 2\n",
+    "root = build_tree(example_roots)\n",
+    "duplicate = find_duplicate(root)\n",
+    "print(f\"Duplicate value: {duplicate}\") "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Duplicate value: -1\n"
      ]
     }
    ],
    "source": [
-    "example_roots = [1, 10, 2, 3, 10, 12, 12]   # Testing the example 3\n",
+    "example_roots = [10, 9, 8, 7]   # Testing example 3\n",
     "root = build_tree(example_roots)\n",
     "duplicate = find_duplicate(root)\n",
     "print(f\"Duplicate value: {duplicate}\") "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {