Code_Craft_countNodes.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNdOqOug6ePYxFIR4kecQdj",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/walkerjian/DailyCode/blob/main/Code_Craft_countNodes.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Problem\n",
        "Given a complete binary tree, count the number of nodes in faster than O(n) time. Recall that a complete binary tree has every level filled except the last, and the nodes in the last level are filled starting from the left."
      ],
      "metadata": {
        "id": "2lWyrXjB8EeD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Solution\n",
        "To count the number of nodes in a complete binary tree in faster than $ O(n) $ time, we can use a divide and conquer approach that exploits the properties of the complete binary tree. The idea is to find the height of the leftmost and rightmost paths of the tree, and if they are equal, it means that the tree is a perfect binary tree for that part, and we can calculate the number of nodes directly using $ 2^{\\text{height}} - 1 $. If the heights are not equal, we recursively calculate the number of nodes in the left and right subtrees.\n",
        "\n",
        "Here is how the algorithm works in detail:\n",
        "\n",
        "1. Compute the height of the leftmost path (left height) and the rightmost path (right height).\n",
        "2. If the left height is equal to the right height, then the tree is a perfect binary tree, and the total number of nodes can be computed as $ 2^{\\text{height}} - 1 $.\n",
        "3. If the left height is not equal to the right height, recursively count the nodes in the left and right subtrees and add 1 for the root node.\n",
        "\n",
        "This approach works faster than $ O(n) $ because it reduces the problem size by approximately half at each step, leading to a time complexity of $ O(\\log^2 n) $."
      ],
      "metadata": {
        "id": "jIohycTB8Hjb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Implementation\n",
        "In this implementation:\n",
        "\n",
        "- `TreeNode` represents a node in the binary tree.\n",
        "- `countNodes` is the function to count the nodes in the complete binary tree.\n",
        "- `get_height` calculates the height of the tree from the left or right edge, depending on the `is_left` flag."
      ],
      "metadata": {
        "id": "pkWuQrLB8K8H"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "TIIt0l_k7Oi1"
      },
      "outputs": [],
      "source": [
        "class TreeNode:\n",
        "    def __init__(self, val=0, left=None, right=None):\n",
        "        self.val = val\n",
        "        self.left = left\n",
        "        self.right = right\n",
        "\n",
        "def countNodes(root):\n",
        "    if not root:\n",
        "        return 0\n",
        "\n",
        "    left_height = get_height(root, True)\n",
        "    right_height = get_height(root, False)\n",
        "\n",
        "    if left_height == right_height:\n",
        "        return (2 ** left_height) - 1\n",
        "    else:\n",
        "        return 1 + countNodes(root.left) + countNodes(root.right)\n",
        "\n",
        "def get_height(node, is_left):\n",
        "    height = 0\n",
        "    while node:\n",
        "        height += 1\n",
        "        node = node.left if is_left else node.right\n",
        "    return height\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Modified Algorithm\n",
        "It's possible to optimize the counting by combining the height calculation with counting the leaves in the last layer to potentially speed up the process. The idea is to first determine the total height of the tree by traversing down the leftmost path. Then, instead of simply checking if the left and right heights are equal, we can perform a binary search on the last level to count the number of leaves. This way, we don't have to traverse the entire tree but only the paths necessary to count the leaves on the last level.\n",
        "\n",
        "Here's how we can approach this:\n",
        "\n",
        "1. Calculate the total height of the tree by traversing the leftmost path.\n",
        "2. Perform a binary search on the last level to find the count of leaves in it. This involves checking whether a node exists at a particular position in the last level, which can be done by following the path determined by the binary representation of the position number.\n",
        "3. Once we have the number of leaves in the last level, we can calculate the total number of nodes in the tree as the sum of the number of nodes in all full levels (which is \\(2^{\\text{height}} - 1\\)) and the number of leaves in the last level.\n",
        "\n",
        "The approach of combining the height calculation with a binary search for the count of leaves in the last layer can be more efficient than traversing the entire tree. This method aims to directly find the missing nodes in the last level of the complete binary tree, thus reducing the number of nodes that need to be visited.\n",
        "\n",
        "Why this method can be more efficient:\n",
        "\n",
        "1. **Height Calculation**: The height of the tree is calculated by traversing only the leftmost path, which takes \\( O(\\log n) \\) time, where \\( n \\) is the total number of nodes in the tree.\n",
        "\n",
        "2. **Binary Search on the Last Level**: The binary search on the last level also takes \\( O(\\log n) \\) time since it halves the search space at each step, and there are at most \\( 2^{\\text{height}} \\) nodes in the last level.\n",
        "\n",
        "3. **Reduced Node Visits**: Instead of visiting every node in the tree, this method specifically targets the last level to find the exact count of nodes, which can significantly reduce the number of node visits, especially in a large tree.\n",
        "\n",
        "Thus, the overall time complexity of this approach is \\( O(\\log^2 n) \\), which comes from the \\( O(\\log n) \\) height calculation and the \\( O(\\log n) \\) binary search. This is more efficient than the \\( O(n) \\) time complexity of a straightforward approach that visits every node.\n",
        "\n",
        "In summary, this optimized method leverages the structure of the complete binary tree to minimize the number of nodes visited during the counting process, which can lead to a significant performance improvement, especially for large trees."
      ],
      "metadata": {
        "id": "S-VXFsRWCtl8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "## Modified implementation\n",
        "In this code:\n",
        "- `get_height` finds the total height of the tree.\n",
        "- `node_exists` checks if a node at a specific index exists in the last level, using a binary path based on the index's binary representation.\n",
        "- The main `countNodes` function uses binary search to find how many leaves are in the last level and then calculates the total number of nodes accordingly.\n",
        "\n"
      ],
      "metadata": {
        "id": "cunixe5mC361"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class TreeNode:\n",
        "    def __init__(self, val=0, left=None, right=None):\n",
        "        self.val = val\n",
        "        self.left = left\n",
        "        self.right = right\n",
        "\n",
        "def countNodes(root):\n",
        "    if not root:\n",
        "        return 0\n",
        "\n",
        "    height = get_height(root)\n",
        "    if height == 0:\n",
        "        return 1\n",
        "\n",
        "    # The number of nodes in the last level can be between 1 and 2^height\n",
        "    left, right = 0, 2**height - 1\n",
        "    while left <= right:\n",
        "        mid = (left + right) // 2\n",
        "        if node_exists(mid, height, root):\n",
        "            left = mid + 1\n",
        "        else:\n",
        "            right = mid - 1\n",
        "\n",
        "    # Total nodes = full tree nodes + last level nodes\n",
        "    return (2**height - 1) + left\n",
        "\n",
        "def get_height(node):\n",
        "    height = 0\n",
        "    while node.left:\n",
        "        node = node.left\n",
        "        height += 1\n",
        "    return height\n",
        "\n",
        "def node_exists(idx, height, node):\n",
        "    left, right = 0, 2**height - 1\n",
        "    for _ in range(height):\n",
        "        mid = (left + right) // 2\n",
        "        if idx <= mid:\n",
        "            node = node.left\n",
        "            right = mid\n",
        "        else:\n",
        "            node = node.right\n",
        "            left = mid + 1\n",
        "    return node is not None"
      ],
      "metadata": {
        "id": "7arfxk2ORsA8"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Testing:\n"
      ],
      "metadata": {
        "id": "wcaruNyfYogT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class TreeNode:\n",
        "    def __init__(self, val=0, left=None, right=None):\n",
        "        self.val = val\n",
        "        self.left = left\n",
        "        self.right = right\n",
        "\n",
        "# Approach 1: Recursively counting all nodes\n",
        "def countNodesRecursive(root):\n",
        "    if not root:\n",
        "        return 0\n",
        "\n",
        "    return 1 + countNodesRecursive(root.left) + countNodesRecursive(root.right)\n",
        "\n",
        "# Approach 2: Using binary search on the last level\n",
        "def countNodesBinarySearch(root):\n",
        "    def get_height(node):\n",
        "        height = 0\n",
        "        while node:\n",
        "            node = node.left\n",
        "            height += 1\n",
        "        return height\n",
        "\n",
        "    def node_exists(idx, height, node):\n",
        "        left, right = 0, 2**(height - 1) - 1\n",
        "        for _ in range(height - 1):\n",
        "            mid = (left + right) // 2\n",
        "            if idx <= mid:\n",
        "                node = node.left\n",
        "                right = mid\n",
        "            else:\n",
        "                node = node.right\n",
        "                left = mid + 1\n",
        "        return node is not None\n",
        "\n",
        "    if not root:\n",
        "        return 0\n",
        "\n",
        "    height = get_height(root) - 1  # Adjusted for 0-based indexing\n",
        "    if height == 0:\n",
        "        return 1\n",
        "\n",
        "    left, right = 0, 2**height - 1\n",
        "    while left <= right:\n",
        "        mid = (left + right) // 2\n",
        "        if node_exists(mid, height, root):\n",
        "            left = mid + 1\n",
        "        else:\n",
        "            right = mid - 1\n",
        "\n",
        "    return (2**height - 1) + left\n",
        "\n",
        "# Testing both approaches with a sample tree\n",
        "# Constructing a complete binary tree\n",
        "#         1\n",
        "#       /   \\\n",
        "#      2     3\n",
        "#     / \\   /\n",
        "#    4   5 6\n",
        "root = TreeNode(1)\n",
        "root.left = TreeNode(2)\n",
        "root.right = TreeNode(3)\n",
        "root.left.left = TreeNode(4)\n",
        "root.left.right = TreeNode(5)\n",
        "root.right.left = TreeNode(6)\n",
        "\n",
        "# Count nodes using both methods\n",
        "count_recursive = countNodesRecursive(root)\n",
        "count_binary_search = countNodesBinarySearch(root)\n",
        "\n",
        "count_recursive, count_binary_search\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "de64oGD3EwVS",
        "outputId": "f40e3cea-420a-49f0-b9b4-e00580174910"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(6, 7)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Issues\n",
        "There is a discrepancy in the node counts between the two methods: the recursive approach counted 6 nodes, while the binary search approach counted 7 nodes. This inconsistency suggests there might be an issue with the binary search implementation, particularly in how the last level's nodes are being counted.\n",
        "\n",
        "To debug and correct the implementation of the binary search method we need to ensure that the height calculation and the binary search logic correctly determine the number of nodes in the last level of the tree.\n",
        "\n",
        "1. **Height Calculation**: Ensure that the height calculation reflects the actual number of levels in the tree.\n",
        "2. **Binary Search**: Verify that the binary search accurately finds the boundary between existing and non-existing nodes in the last level.\n",
        "\n",
        "##Correction\n"
      ],
      "metadata": {
        "id": "nDsJGcwkGlq8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class TreeNode:\n",
        "    def __init__(self, val=0, left=None, right=None):\n",
        "        self.val = val\n",
        "        self.left = left\n",
        "        self.right = right\n",
        "\n",
        "# Approach 1: Recursively counting all nodes\n",
        "def countNodesRecursive(root):\n",
        "    if not root:\n",
        "        return 0\n",
        "\n",
        "    return 1 + countNodesRecursive(root.left) + countNodesRecursive(root.right)\n",
        "\n",
        "# Approach 2: Using binary search on the last level\n",
        "def countNodesBinarySearch(root):\n",
        "    def get_height(node):\n",
        "        height = 0\n",
        "        while node:\n",
        "            node = node.left\n",
        "            height += 1\n",
        "        return height\n",
        "\n",
        "    def node_exists(idx, height, node):\n",
        "        left, right = 0, 2**(height - 1) - 1\n",
        "        for _ in range(height - 1):\n",
        "            mid = (left + right) // 2\n",
        "            if idx <= mid:\n",
        "                node = node.left\n",
        "                right = mid\n",
        "            else:\n",
        "                node = node.right\n",
        "                left = mid + 1\n",
        "        return node is not None\n",
        "\n",
        "    if not root:\n",
        "        return 0\n",
        "\n",
        "    height = get_height(root) - 1  # Adjusted for 0-based indexing\n",
        "    if height == 0:\n",
        "        return 1\n",
        "\n",
        "    left, right = 0, 2**height - 1\n",
        "    while left <= right:\n",
        "        mid = (left + right) // 2\n",
        "        if node_exists(mid, height, root):\n",
        "            left = mid + 1\n",
        "        else:\n",
        "            right = mid - 1\n",
        "\n",
        "    return (2**height - 1) + left\n",
        "\n",
        "# Testing both approaches with a sample tree\n",
        "# Constructing a complete binary tree\n",
        "#         1\n",
        "#       /   \\\n",
        "#      2     3\n",
        "#     / \\   /\n",
        "#    4   5 6\n",
        "root = TreeNode(1)\n",
        "root.left = TreeNode(2)\n",
        "root.right = TreeNode(3)\n",
        "root.left.left = TreeNode(4)\n",
        "root.left.right = TreeNode(5)\n",
        "root.right.left = TreeNode(6)\n",
        "\n",
        "# Count nodes using both methods\n",
        "count_recursive = countNodesRecursive(root)\n",
        "count_binary_search = countNodesBinarySearch(root)\n",
        "\n",
        "count_recursive, count_binary_search\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m-Mi_qIxFAbw",
        "outputId": "814f8e3f-814a-41a0-e005-31d283c6c538"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(6, 7)"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Correcting the binary search approach\n",
        "\n",
        "def countNodesBinarySearchCorrected(root):\n",
        "    def get_height(node):\n",
        "        height = 0\n",
        "        while node.left:  # Only traverse through the left to get the height\n",
        "            node = node.left\n",
        "            height += 1\n",
        "        return height\n",
        "\n",
        "    def node_exists(idx, height, node):\n",
        "        left, right = 0, 2**height - 1\n",
        "        for _ in range(height):\n",
        "            mid = (left + right) // 2\n",
        "            if idx <= mid:\n",
        "                node = node.left\n",
        "                right = mid\n",
        "            else:\n",
        "                node = node.right\n",
        "                left = mid + 1\n",
        "        return node is not None\n",
        "\n",
        "    if not root:\n",
        "        return 0\n",
        "\n",
        "    height = get_height(root)\n",
        "    if height == 0:  # Tree with only one node\n",
        "        return 1\n",
        "\n",
        "    left, right = 0, 2**height - 1\n",
        "    while left <= right:\n",
        "        mid = (left + right) // 2\n",
        "        if node_exists(mid, height, root):\n",
        "            left = mid + 1\n",
        "        else:\n",
        "            right = mid - 1\n",
        "\n",
        "    # Nodes in the last level are counted by left index in the binary search\n",
        "    return (2**height) + left - 1\n",
        "\n",
        "# Retesting the corrected binary search method\n",
        "count_binary_search_corrected = countNodesBinarySearchCorrected(root)\n",
        "\n",
        "count_recursive, count_binary_search_corrected\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nccr5k_kFJap",
        "outputId": "beacf3b6-ec65-4369-bbd9-558657cdf972"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(6, 6)"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Visual Verification"
      ],
      "metadata": {
        "id": "9z61pSC_HU9s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_tree(root):\n",
        "    if not root:\n",
        "        return \"The tree is empty.\"\n",
        "\n",
        "    # Function to add nodes and edges to the graph\n",
        "    def add_nodes_edges(node, pos, x=0, y=0, layer=1):\n",
        "        pos[node] = (x, y)\n",
        "        if node.left:\n",
        "            pos, layer = add_nodes_edges(node.left, pos, x - 1 / layer, y - 1, layer + 1)\n",
        "        if node.right:\n",
        "            pos, layer = add_nodes_edges(node.right, pos, x + 1 / layer, y - 1, layer + 1)\n",
        "        return pos, layer\n",
        "\n",
        "    # Initialize the graph and position dictionary\n",
        "    graph = nx.DiGraph()\n",
        "    pos = {}\n",
        "    pos, _ = add_nodes_edges(root, pos)\n",
        "\n",
        "    # Create labels for nodes\n",
        "    labels = {node: node.val for node in pos.keys()}\n",
        "\n",
        "    # Add nodes and edges to the graph\n",
        "    for node in pos.keys():\n",
        "        graph.add_node(node)\n",
        "        if node.left:\n",
        "            graph.add_edge(node, node.left)\n",
        "        if node.right:\n",
        "            graph.add_edge(node, node.right)\n",
        "\n",
        "    # Draw the tree\n",
        "    nx.draw(graph, pos, labels=labels, with_labels=True, node_size=700, node_color='skyblue', font_size=10, arrows=False)\n",
        "    plt.title(\"Binary Tree Representation\")\n",
        "    plt.show()\n",
        "\n",
        "plot_tree(root)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 539
        },
        "id": "DJRQsWLUEnew",
        "outputId": "1d54100d-def0-401c-d3e9-f664e4823d32"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The binary tree has been successfully plotted, displaying the structure of the tree from the root down, with each node and its connections. This visualization helps to understand the tree's layout and the relationships between nodes."
      ],
      "metadata": {
        "id": "6Gh41KSa8HDP"
      }
    }
  ]
}