Assignment 1

Author: nipunpuri

02_activities/assignments/assignment_1.ipynb

@@ -21,7 +21,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 85,
+   "execution_count": 90,
    "metadata": {},
    "outputs": [
     {
@@ -88,9 +88,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 91,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "IndentationError",
+     "evalue": "expected an indented block (2850872121.py, line 8)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  Cell \u001b[0;32mIn[91], line 8\u001b[0;36m\u001b[0m\n\u001b[0;31m    # TODO\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
+     ]
+    }
+   ],
    "source": [
     "# Definition for a binary tree node.\n",
     "# class TreeNode(object):\n",
@@ -138,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 106,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -215,8 +224,7 @@
     }
    },
    "source": [
-    "I have a binary tree, I want to find all possible way I can get from the top (or the root node) to the bottom (leaf).\n",
-    "Since, there are multiple leaves. I have multiple paths."
+    "Given a binary tree, the task is to find all the possible paths from the top (root node) to the botton (left) of the tree."
    ]
   },
   {
@@ -240,6 +248,7 @@
     "[('1', '2', '4'), ('1', '2', '5'), ('1', '3', '6'), ('1', '3', '7')]\n",
     "\n",
     "# Tree # 2\n",
+    "# the data type in different nodes can be different too\n",
     "[1, 2, 3,  3, 5 , 'my_Leaf']\n",
     "#hould return\n",
     "[('1', '2', '3'), ('1', '2', '5'), ('1', '3', 'my_Leaf')]"
@@ -255,7 +264,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 86,
+   "execution_count": 93,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -294,7 +303,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 87,
+   "execution_count": 95,
    "metadata": {},
    "outputs": [
     {
@@ -355,7 +364,15 @@
    "source": [
     "# Your answer here\n",
     "\n",
-    "It can be broken down into a recursive method, because a big tree is made up a smaller trees. A binary free is made up of 2 smaller trees"
+    "It can be broken down into a recursive method, because a big tree is made up a smaller trees. A binary free is made up of 2 smaller trees.\n",
+    "\n",
+    "\n",
+    "1. Start at the root → Add the current node’s value to the path list and move down the tree.\n",
+    "2. Recursively explore left and right children → Call DFS on the left child first, then the right child.   \n",
+    "    2.1 For each node, I store the path taken into a list - 'path'\n",
+    "3. If a leaf node is reached (no left or right child) → Convert path to a tuple (so that it is immutable now, and can-not be changed) and append it in the list - result\n",
+    "4. Backtrack → Remove the last node from path (pop()) and try a different path.\n",
+    "5. Continue until all nodes are visited (if not node, base case) → Once all paths are collected, return the final result list."
    ]
   },
   {
@@ -400,23 +417,20 @@
    "source": [
     "# Your answer here\n",
     "\n",
-    "Another method is using a stack data-structure. First understand how this DS works:\n",
+    "Instead of using a recursive method, I can also use stack data structures\n",
     "\n",
-    "A stack is a data structure that works like a stack of plates:\n",
+    "First explaination of how a stack data strucutre would work. A stack is a data structure that works like a stack of plates:\n",
     "\n",
-    "1. You add items to the top (push).\n",
-    "2. You remove items from the top (pop). - LIFO\n",
+    "1. You add items to the top (push). (Implement by adding a new element to the left hand side of the list, do-not use append. Use insert(0 , 'value'))\n",
+    "2. You remove items from the top (pop). - LIFO. (Use pop to remove the right most element)\n",
     "3. The last item added is the first one removed (Last In, First Out → LIFO)\n",
     "\n",
-    "This can be implemented in python using lists\n",
-    "\n",
-    "Now depth first seach using stacks:\n",
-    "\n",
+    "This is how we can implement DFS using stacks\n",
     "\n",
-    "1. Start with the root and put it in the stack.\n",
+    "1. Start with the root and put it in the stack. (This the root node on the top of the tree)\n",
     "2. Take a node from the stack, check if it’s a leaf (has no children).\n",
     "        - If it’s a leaf, save its path.\n",
-    "        - If not, add its children to the stack (right child first, then left).\n",
+    "        - If not, add its children to the stack (right child first, then left). -> This way the childs are also added to the 'list' of things to check\n",
     "3. Repeat until we’ve visited all nodes.\n",
     "4. Since we use a stack, we process the left side first (because stacks work in Last In, First Out order)."
    ]