some updates to BST notebook

Author: jsgoller1

implementations/Data Structure - Binary Search Trees.ipynb

@@ -179,21 +179,21 @@
     "\n",
     "> The trace of a traversal is called a sequentialisation of the tree. The traversal trace is a list of each visited root. No one sequentialisation according to pre-, in- or post-order describes the underlying tree uniquely. Given a tree with distinct elements, either pre-order or post-order paired with in-order is sufficient to describe the tree uniquely. ([Wikipedia](https://en.wikipedia.org/wiki/Tree_traversal#In-order_(LNR)))\n",
     "\n",
-    "Note that pre/in/post order traversals can be used to implement depth first searches, while level-order traversals can be used to implement breadth first searches. Orderings may be reversed by visiting the right child before the left. Depth-first traversals can be implemented iteratively using a stack or recursively (implicitly using the call stack):"
+    "The most straightforward way to implement pre/in/post-order traversals uses recursion. Note that below, we can easily change from pre- to in- or post- order by simply changing where we call to `print()`, and can reverse the order by swapping the left and right:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0 1 3 4 2 5 6 \n",
-      "--------------\n",
-      "0 1 3 4 2 5 6 "
+      "Pre-order: 0 1 3 4 2 5 6  \n",
+      "In-order: 3 1 4 0 5 2 6  \n",
+      "Post-order: 3 4 1 5 6 2 0  \n"
      ]
     }
    ],
@@ -206,73 +206,118 @@
     "  / \\    / \\ \n",
     " 3   4  5   6 \n",
     "\"\"\"\n",
-    "\n",
     "def pre_order_recursive(node: TreeNode):\n",
-    "    if not node:\n",
-    "        return\n",
-    "    print(node.val, end =\" \")\n",
-    "    pre_order_recursive(node.left) if node.left else None\n",
-    "    pre_order_recursive(node.right) if node.right else None\n",
+    "    if not node: return\n",
+    "    print(node.val, end=\" \")\n",
+    "    pre_order_recursive(node.left)\n",
+    "    pre_order_recursive(node.right) \n",
+    "print(f\"Pre-order:\", end=\" \")\n",
     "pre_order_recursive(root)\n",
+    "print(\" \")\n",
     "\n",
-    "print(\"\\n\"+(\"-\"*14))\n",
     "\n",
-    "def pre_order_recursive(tree: List[int], i: int):\n",
-    "    if not (0 <= i <=len(tree)-1):\n",
-    "        return\n",
-    "    print(tree[i], end =\" \")\n",
-    "    pre_order_recursive(tree, 2*i+1) if 2*i+1 < len(tree) else None\n",
-    "    pre_order_recursive(tree, 2*i+2) if 2*i+2 < len(tree)  else None\n",
-    "pre_order_recursive(tree_as_arr, 0)"
+    "def in_order_recursive(node: TreeNode):\n",
+    "    if not node: return\n",
+    "    in_order_recursive(node.left)\n",
+    "    print(node.val, end=\" \")\n",
+    "    in_order_recursive(node.right)\n",
+    "print(f\"In-order:\", end=\" \")\n",
+    "in_order_recursive(root)\n",
+    "print(\" \")\n",
+    "\n",
+    "def post_order_recursive(node: TreeNode):\n",
+    "    if not node: return\n",
+    "    post_order_recursive(node.left)\n",
+    "    post_order_recursive(node.right)\n",
+    "    print(node.val, end=\" \")\n",
+    "print(f\"Post-order:\", end=\" \")\n",
+    "post_order_recursive(root)\n",
+    "print(\" \")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Traversals can also be implemented explicitly using a stack. Iterative versions are not as straightforward and make for great interview questions:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0 1 3 4 2 5 6 \n",
-      "--------------\n",
-      "0 1 3 4 2 5 6 "
+      "Pre-order: [0, 1, 3, 4, 2, 5, 6]\n",
+      "In-order: [3, 1, 4, 0, 5, 2, 6]\n",
+      "Post-order: [3, 4, 1, 5, 6, 2, 0]\n"
      ]
     }
    ],
    "source": [
+    "\"\"\"\n",
+    "      0\n",
+    "    /    \\\n",
+    "   1      2\n",
+    "  / \\    / \\ \n",
+    " 3   4  5   6 \n",
+    "\n",
+    "\"\"\"\n",
+    "\n",
     "def pre_order_iterative(node: TreeNode):\n",
+    "    traversal = []\n",
     "    stack = [node]\n",
     "    while stack:\n",
     "        curr = stack.pop()\n",
-    "        print(curr.val, end =\" \")\n",
-    "        # Note that right is pushed first when using a stack explicitly,\n",
-    "        # causing it to be evaluated after left.\n",
-    "        stack.append(curr.right) if curr.right else None \n",
-    "        stack.append(curr.left) if curr.left else None\n",
-    "pre_order_iterative(root)\n",
-    "\n",
-    "print(\"\\n\"+(\"-\"*14))\n",
-    "\n",
-    "def pre_order_iterative(tree: List[int]):\n",
-    "    if not tree:\n",
-    "        return\n",
-    "    stack = [0]\n",
-    "    while stack:\n",
-    "        i = stack.pop()\n",
-    "        print(i, end =\" \")\n",
-    "        stack.append(2*i+2) if 2*i+2 < len(tree) else None \n",
-    "        stack.append(2*i+1) if 2*i+1 < len(tree)  else None\n",
-    "pre_order_iterative(tree_as_arr)"
+    "        if curr:\n",
+    "            traversal.append(curr.val)\n",
+    "            stack.append(curr.right)\n",
+    "            stack.append(curr.left)\n",
+    "    return traversal\n",
+    "print(f\"Pre-order: {pre_order_iterative(root)}\") \n",
+    "\n",
+    "def in_order_iterative(node: TreeNode):\n",
+    "    traversal = []\n",
+    "    stack = []\n",
+    "    while node or stack:\n",
+    "        if node:\n",
+    "            stack.append(node)\n",
+    "            node = node.left\n",
+    "        else:\n",
+    "            node = stack.pop()\n",
+    "            traversal.append(node.val)\n",
+    "            node = node.right\n",
+    "    return traversal        \n",
+    "print(f\"In-order: {in_order_iterative(root)}\")\n",
+    "\n",
+    "def post_order_iterative(node: TreeNode):\n",
+    "    traversal = []\n",
+    "    stack = []\n",
+    "    prev_node = None\n",
+    "    while stack or node:\n",
+    "        if node:\n",
+    "            stack.append(node)\n",
+    "            node = node.left\n",
+    "        else:\n",
+    "            peek = stack[-1] \n",
+    "            if peek.right and prev_node != peek.right:\n",
+    "                node = peek.right\n",
+    "            else:\n",
+    "                traversal.append(peek.val)\n",
+    "                prev_node = stack.pop()\n",
+    "    return traversal\n",
+    " \n",
+    "print(f\"Post-order: {post_order_iterative(root)}\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note that in the above, we can easily change from pre- to in- or post- order by simply reordering the calls to \n",
-    "`print()` and visitng the children."
+    "Level order traversal is implemented iteratively, but using a queue (most easily via `collections.deque()` in Python), and can be used for breadth-first searches:"
    ]
   },
   {
@@ -284,66 +329,51 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "3 1 4 0 5 2 6 "
+      "0 1 2 3 4 5 6 "
      ]
     }
    ],
    "source": [
-    "def in_order_recursive(node: TreeNode):\n",
-    "    if not node:\n",
-    "        return\n",
-    "    in_order_recursive(node.left) if node.left else None\n",
-    "    print(node.val, end =\" \")\n",
-    "    in_order_recursive(node.right) if node.right else None\n",
-    "in_order_recursive(root)"
+    "from collections import deque\n",
+    "\n",
+    "def level_order_iterative(node: TreeNode):\n",
+    "    q = deque([node])\n",
+    "    while q:\n",
+    "        curr = q.popleft()\n",
+    "        print(curr.val, end =\" \")\n",
+    "        q.append(curr.left) if curr.left else None\n",
+    "        q.append(curr.right) if curr.right else None \n",
+    "level_order_iterative(root)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Level order traversal is implemented iteratively, but using a queue (most easily via `collections.deque()` in Python):"
+    "Also, remember that each type of traversal can be implemented using an array instead of a node type if given, though this tends to be more wasteful if the BST isn't complete:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 52,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0 1 2 3 4 5 6 \n",
-      "--------------\n",
-      "0 1 2 3 4 5 6 "
+      "0 1 3 4 2 5 6 "
      ]
     }
    ],
    "source": [
-    "from collections import deque\n",
-    "\n",
-    "def level_order_iterative(node: TreeNode):\n",
-    "    q = deque([node])\n",
-    "    while q:\n",
-    "        curr = q.popleft()\n",
-    "        print(curr.val, end =\" \")\n",
-    "        q.append(curr.left) if curr.left else None\n",
-    "        q.append(curr.right) if curr.right else None \n",
-    "level_order_iterative(root)\n",
-    "\n",
-    "print(\"\\n\"+(\"-\"*14))\n",
-    "\n",
-    "def level_order_iterative(tree: List[int]):\n",
-    "    if not tree:\n",
+    "def pre_order_arr(tree: List[int], i: int):\n",
+    "    if not (0 <= i <=len(tree)-1):\n",
     "        return\n",
-    "    q = deque([0])\n",
-    "    while q:\n",
-    "        i = q.popleft()\n",
-    "        print(i, end =\" \")\n",
-    "        q.append(2*i+1) if 2*i+1 < len(tree) else None\n",
-    "        q.append(2*i+2) if 2*i+2 < len(tree) else None \n",
-    "level_order_iterative(tree_as_arr)"
+    "    print(tree[i], end =\" \")\n",
+    "    pre_order_arr(tree, 2*i+1)\n",
+    "    pre_order_arr(tree, 2*i+2)\n",
+    "pre_order_arr(tree_as_arr, 0)"
    ]
   },
   {
@@ -376,17 +406,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "3 1 4 0 5 2 6 "
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "\"\"\"\n",
     "      0\n",
@@ -439,7 +461,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -499,18 +521,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1\n",
-      "8\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "def bst_min(node):\n",
     "    if not node:\n",
@@ -541,11 +554,6 @@
     "- If `n` has no right child, search upwards until we reach a node `l` who is the left of child of its parent; `l.parent` is the successor."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  },
   {
    "cell_type": "markdown",
    "metadata": {},