{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "eb4e80c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# balanced binary search tree\n",
    "#\n",
    "# we are using the same data structure a) for a tree and b) for a node in that tree\n",
    "#\n",
    "# note that this is a sorted data structure:\n",
    "# for each node in the tree (including the root node), our implementation needs to make sure that\n",
    "#    a) all items within the self._left subtree are smaller than self._item\n",
    "#    b) all items within the self._right subtree are greater than or equal to self._item\n",
    "#\n",
    "import numpy as np\n",
    "\n",
    "class BalancedBST:\n",
    "    def __init__(self):\n",
    "        self._left = None\n",
    "        self._item = None\n",
    "        self._right = None\n",
    "        self._size = 0\n",
    "\n",
    "    def get_root_item(self):\n",
    "        return self._item\n",
    "    \n",
    "    # returns True if the tree contains value, False otherwise\n",
    "    #\n",
    "    def contains(self, value):\n",
    "        return self._find_node(value) is not None\n",
    "    \n",
    "    def is_empty(self):\n",
    "        return self._item is None\n",
    "    \n",
    "    # returns the number of data items stored in the tree\n",
    "    #\n",
    "    def get_size(self):\n",
    "        return self._size\n",
    "\n",
    "    # returns the smallest value stored in the tree data structure\n",
    "    #\n",
    "    def get_smallest(self):\n",
    "        if self._left is None:\n",
    "            return self._item\n",
    "        else:\n",
    "            return self._left.get_smallest()\n",
    "        \n",
    "    # returns the greatest value stored in the tree data structure\n",
    "    #\n",
    "    def get_greatest(self):\n",
    "        if self._right is None:\n",
    "            return self._item\n",
    "        else:\n",
    "            return self._right.get_greatest()\n",
    "    \n",
    "    # removes all content from the tree\n",
    "    #\n",
    "    def clear(self):\n",
    "        # if self._left is not None:\n",
    "        #     self._left.clear()\n",
    "        # if self._right is not None:\n",
    "        #     self._right.clear()\n",
    "        self._left = None\n",
    "        self._item = None\n",
    "        self._right = None\n",
    "        self._size = 0\n",
    "    \n",
    "    # attach an additional node to the tree, containing the value passed as an argument\n",
    "    #\n",
    "    # if the tree already contains the value, it will be added nonetheless\n",
    "    #\n",
    "    def insert(self, value):\n",
    "        if self._item is None:\n",
    "            self._item = value\n",
    "        elif value < self._item:\n",
    "            if self._left is None:\n",
    "                self._left = BalancedBST()\n",
    "                self._left._item = value\n",
    "            else:\n",
    "                self._left.insert(value)\n",
    "        else:\n",
    "            if self._right is None:\n",
    "                self._right = BalancedBST()\n",
    "                self._right._item = value\n",
    "            else:\n",
    "                self._right.insert(value)\n",
    "        self._size += 1\n",
    "        if self._size < 10:\n",
    "            return  # no need to balance trees with fewer than ten elements\n",
    "        \n",
    "        # now check whether the tree needs to be rebalanced\n",
    "        #\n",
    "        if self._left is None:\n",
    "            self._balance()\n",
    "        elif self._right is None:\n",
    "            self._balance()\n",
    "        elif self._left._size >= 4*self._right._size or self._right._size >= 4*self._left._size:\n",
    "            self._balance()\n",
    "    \n",
    "    # replaces the content of self with the content of a dyn. array (Python list)\n",
    "    #\n",
    "    def copy_from_dynarray(self, dynarray):\n",
    "        self.clear()\n",
    "        for el in dynarray:\n",
    "            self.insert(el)\n",
    "    \n",
    "    # traversal of the binary search tree\n",
    "    #\n",
    "    # appends the content of self, in ascending order, to a Python list (dyn. array)\n",
    "    #\n",
    "    def append_to_dynarray(self, dynarray):\n",
    "        if self._left is not None:\n",
    "            self._left.append_to_dynarray(dynarray)\n",
    "        dynarray.append(self._item)\n",
    "        if self._right is not None:\n",
    "            self._right.append_to_dynarray(dynarray)\n",
    "    \n",
    "    # traversal of the binary search tree\n",
    "    #\n",
    "    def write_into_array(self, arr, idx):\n",
    "        if self._left is not None:\n",
    "            idx = self._left.write_into_array(arr, idx)\n",
    "        if self._item is not None:\n",
    "            arr[idx] = self._item\n",
    "            idx += 1\n",
    "        if self._right is not None:\n",
    "            idx = self._right.write_into_array(arr, idx)\n",
    "        return idx\n",
    "    \n",
    "    # returns a string representing the tree structure\n",
    "    #\n",
    "    def to_string(self):\n",
    "        if self._item is None:\n",
    "            return \"[]\"\n",
    "        if self._left is None and self._right is None:\n",
    "            return str(self._item)\n",
    "        content = str(self._item)\n",
    "        if self._left is not None:\n",
    "            content = content + \" -> [\" + self._left.to_string() + \"]\"\n",
    "        else:\n",
    "            content = content + \" -> []\"\n",
    "        if self._right is not None:\n",
    "            content = content + \", [\" + self._right.to_string() + \"]\"\n",
    "        else:\n",
    "            content = content + \", []\"\n",
    "        return content\n",
    "\n",
    "    # returns the/a node containing an item with a certain value\n",
    "    #\n",
    "    # if no such node exists, None is returned\n",
    "    #\n",
    "    def _find_node(self, value):\n",
    "        if self._item is None:\n",
    "            return None\n",
    "        elif self._item == value:\n",
    "            return self\n",
    "        elif value < self._item:\n",
    "            if self._left is None:\n",
    "                return None\n",
    "            else:\n",
    "                return self._left._find_node(value)\n",
    "        else:\n",
    "            if self._right is None:\n",
    "                return None\n",
    "            else:\n",
    "                return self._right._find_node(value)\n",
    "    \n",
    "    # rebalance the tree\n",
    "    #\n",
    "    def _balance(self):\n",
    "        size = self._size\n",
    "        if size < 10:  # unnecessary to rebalance smaller binary search trees\n",
    "            return\n",
    "        arr = np.empty(size+1, dtype=int)\n",
    "        self.write_into_array(arr, 0)  # note that this array is already sorted\n",
    "        self.clear()  # now we have all in the temporary storage and can rebuild the tree\n",
    "        self._rebuild_from_sorted_array(arr, 0, size-1)  # recursively insert all data from the array\n",
    "\n",
    "    def _rebuild_from_sorted_array(self, x, idx_min, idx_max):  # range x[idx_min: idx_max+1]\n",
    "        # print(\"\\treinserting\", x[idx_min: idx_max+1], \"; \", idx_min, idx_max)\n",
    "        idx_mid = (idx_min + idx_max) // 2  # mid point as in binary search\n",
    "        # print(\"\\t\\treinserting\", x[idx_mid], \"; \", idx_mid)\n",
    "        self._item = x[idx_mid]\n",
    "        if idx_mid-1 >= idx_min:\n",
    "            self._left = BalancedBST()\n",
    "            self._left._rebuild_from_sorted_array(x, idx_min, idx_mid-1)\n",
    "        if idx_max >= idx_mid+1:\n",
    "            self._right = BalancedBST()\n",
    "            self._right._rebuild_from_sorted_array(x, idx_mid+1, idx_max)\n",
    "        self._size = idx_max - idx_min + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "14dbed7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# binary search tree (version without balancing, for comparison)\n",
    "#\n",
    "# we are using the same data structure a) for a tree and b) for a node in that tree\n",
    "#\n",
    "# note that this is a sorted data structure:\n",
    "# for each node in the tree (including the root node), our implementation needs to make sure that\n",
    "#    a) all items within the self._left subtree are smaller than self._item\n",
    "#    b) all items within the self._right subtree are greater than or equal to self._item\n",
    "#\n",
    "class BinarySearchTree:\n",
    "    def __init__(self):\n",
    "        self._left = None\n",
    "        self._item = None\n",
    "        self._right = None\n",
    "\n",
    "    def get_root_item(self):\n",
    "        return self._item\n",
    "    \n",
    "    # returns True if the tree contains value, False otherwise\n",
    "    #\n",
    "    def contains(self, value):\n",
    "        return self._find_node(value) is not None\n",
    "    \n",
    "    def is_empty(self):\n",
    "        return self._item is None\n",
    "    \n",
    "    # returns the number of data items stored in the tree\n",
    "    #\n",
    "    def get_size(self):\n",
    "        if self._item is None:\n",
    "            return 0\n",
    "        size = 1\n",
    "        if self._left is not None:\n",
    "            size += self._left.get_size()\n",
    "        if self._right is not None:\n",
    "            size += self._right.get_size()\n",
    "        return size\n",
    "\n",
    "    # returns the smallest value stored in the tree data structure\n",
    "    #\n",
    "    def get_smallest(self):\n",
    "        if self._left is None:\n",
    "            return self._item\n",
    "        else:\n",
    "            return self._left.get_smallest()\n",
    "        \n",
    "    # returns the greatest value stored in the tree data structure\n",
    "    #\n",
    "    def get_greatest(self):\n",
    "        if self._right is None:\n",
    "            return self._item\n",
    "        else:\n",
    "            return self._right.get_greatest()\n",
    "    \n",
    "    # removes all content from the tree\n",
    "    #\n",
    "    def clear(self):\n",
    "        if self._left is not None:\n",
    "            self._left.clear()\n",
    "        if self._right is not None:\n",
    "            self._right.clear()\n",
    "        self._left = None\n",
    "        self._item = None\n",
    "        self._right = None\n",
    "    \n",
    "    # attach an additional node to the tree, containing the value passed as an argument\n",
    "    #\n",
    "    # if the tree already contains the value, it will be added nonetheless\n",
    "    #\n",
    "    def insert(self, value):\n",
    "        if self._item is None:\n",
    "            self._item = value\n",
    "        elif value < self._item:\n",
    "            if self._left is None:\n",
    "                self._left = BinarySearchTree()\n",
    "                self._left._item = value\n",
    "            else:\n",
    "                self._left.insert(value)\n",
    "        else:\n",
    "            if self._right is None:\n",
    "                self._right = BinarySearchTree()\n",
    "                self._right._item = value\n",
    "            else:\n",
    "                self._right.insert(value)\n",
    "    \n",
    "    # replaces the content of self with the content of a dyn. array (Python list)\n",
    "    #\n",
    "    def copy_from_dynarray(self, dynarray):\n",
    "        self.clear()\n",
    "        for el in dynarray:\n",
    "            self.insert(el)\n",
    "    \n",
    "    # traversal of the binary search tree\n",
    "    #\n",
    "    # appends the content of self, in ascending order, to a Python list (dyn. array)\n",
    "    #\n",
    "    def append_to_dynarray(self, dynarray):\n",
    "        if self._left is not None:\n",
    "            self._left.append_to_dynarray(dynarray)\n",
    "        dynarray.append(self._item)\n",
    "        if self._right is not None:\n",
    "            self._right.append_to_dynarray(dynarray)\n",
    "    \n",
    "    # returns a string representing the tree structure\n",
    "    #\n",
    "    def to_string(self):\n",
    "        if self._item is None:\n",
    "            return \"[]\"\n",
    "        if self._left is None and self._right is None:\n",
    "            return str(self._item)\n",
    "        content = str(self._item)\n",
    "        if self._left is not None:\n",
    "            content = content + \" -> [\" + self._left.to_string() + \"]\"\n",
    "        else:\n",
    "            content = content + \" -> []\"\n",
    "        if self._right is not None:\n",
    "            content = content + \", [\" + self._right.to_string() + \"]\"\n",
    "        else:\n",
    "            content = content + \", []\"\n",
    "        return content\n",
    "\n",
    "    # returns the/a node containing an item with a certain value\n",
    "    #\n",
    "    # if no such node exists, None is returned\n",
    "    #\n",
    "    def _find_node(self, value):\n",
    "        if self._item is None:\n",
    "            return None\n",
    "        elif self._item == value:\n",
    "            return self\n",
    "        elif value < self._item:\n",
    "            if self._left is None:\n",
    "                return None\n",
    "            else:\n",
    "                return self._left._find_node(value)\n",
    "        else:\n",
    "            if self._right is None:\n",
    "                return None\n",
    "            else:\n",
    "                return self._right._find_node(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "115a55d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test_tree: 7 -> [4 -> [3 -> [1], []], []], [25 -> [13 -> [], [23]], [25 -> [], [111 -> [], [111 -> [], [111]]]]]\n",
      "root node item: 7\n",
      "rebalancing\n",
      "test_tree: 23 -> [4 -> [1 -> [], [3]], [7 -> [], [13]]], [111 -> [25 -> [], [25]], [111 -> [], [111]]]\n",
      "root node item: 23\n",
      "does the tree contain 13?: True\n",
      "test that the node with 13 is found: 13\n",
      "does the tree contain 12?: False\n",
      "test that _find_node(12) returns None: True\n"
     ]
    }
   ],
   "source": [
    "# minor test\n",
    "#\n",
    "test_tree = BalancedBST()\n",
    "test_tree.copy_from_dynarray([7, 4, 25, 3, 13, 23, 25, 1, 111, 111, 111])\n",
    "\n",
    "print(\"test_tree:\", test_tree.to_string())\n",
    "print(\"root node item:\", test_tree.get_root_item())\n",
    "\n",
    "print(\"rebalancing\")\n",
    "test_tree._balance()\n",
    "print(\"test_tree:\", test_tree.to_string())\n",
    "print(\"root node item:\", test_tree.get_root_item())\n",
    "\n",
    "print(\"does the tree contain 13?:\", test_tree.contains(13))\n",
    "test_tree._find_node(13)\n",
    "print(\"test that the node with 13 is found:\", test_tree._find_node(13).get_root_item())\n",
    "\n",
    "print(\"does the tree contain 12?:\", test_tree.contains(12))\n",
    "test_tree._find_node(12)\n",
    "print(\"test that _find_node(12) returns None:\", test_tree._find_node(12) is None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "41448ac0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test_list: [1, 3, 4, 7, 13, 23, 25, 25, 111, 111, 111]\n"
     ]
    }
   ],
   "source": [
    "test_list = []\n",
    "test_tree.append_to_dynarray(test_list)\n",
    "print(\"test_list:\", test_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "8ddd4616",
   "metadata": {},
   "outputs": [],
   "source": [
    "def natmatch_brute_force(x, y):\n",
    "    for i in range(len(x)):\n",
    "        for j in range(i+1, len(x)):\n",
    "            if (x[i]+x[j] == y) and (x[i] != x[j]):\n",
    "                return [x[i], x[j]]\n",
    "    return []\n",
    "\n",
    "def natmatch_dict(x, y):\n",
    "    mydict = {}\n",
    "    for i in range(len(x)):\n",
    "        c = y - x[i]\n",
    "        if c in mydict:\n",
    "            return [c, x[i]]\n",
    "        mydict[x[i]] = i\n",
    "    return []\n",
    "\n",
    "def natmatch_dynarray(x, y):\n",
    "    mylist = []\n",
    "    for i in range(len(x)):\n",
    "        c = y - x[i]\n",
    "        if c in mylist:\n",
    "            return [c, x[i]]\n",
    "        mylist.append(x[i])\n",
    "    return []\n",
    "\n",
    "def natmatch_BST(x, y):\n",
    "    tree = BinarySearchTree()\n",
    "    for i in range(len(x)):\n",
    "        c = y - x[i]\n",
    "        if tree.contains(c):\n",
    "            return [c, x[i]]\n",
    "        tree.insert(x[i])\n",
    "    return []\n",
    "\n",
    "def natmatch_BBST(x, y):\n",
    "    tree = BalancedBST()\n",
    "    for i in range(len(x)):\n",
    "        c = y - x[i]\n",
    "        if tree.contains(c):\n",
    "            return [c, x[i]]\n",
    "        tree.insert(x[i])\n",
    "    return []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "1d2871b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List x = [16, 97, 128, 84, 213, 76, 131, 211, 60, 68, 201, 130, 65, 45, 102] where y = 225\n",
      "Brute force: Return value obtained as [97, 128]\n",
      "Dictionary storage: Return value obtained as [97, 128]\n",
      "Dynamic array storage: Return value obtained as [97, 128]\n",
      "Simple BST storage: Return value obtained as [97, 128]\n",
      "Balanced BST storage: Return value obtained as [97, 128]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "k = 15\n",
    "\n",
    "random.seed()\n",
    "x = [random.randrange(k*k) for j in range(k)]\n",
    "print(\"List x =\", x, \"where y =\", k*k)\n",
    "print(\"Brute force: Return value obtained as\", natmatch_brute_force(x, k*k))\n",
    "print(\"Dictionary storage: Return value obtained as\", natmatch_dict(x, k*k))\n",
    "print(\"Dynamic array storage: Return value obtained as\", natmatch_dynarray(x, k*k))\n",
    "print(\"Simple BST storage: Return value obtained as\", natmatch_BST(x, k*k))\n",
    "print(\"Balanced BST storage: Return value obtained as\", natmatch_BBST(x, k*k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "a8f8605d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\t1.049041748046875e-06\t1.0776519775390624e-06\t9.822845458984375e-07\t1.7642974853515626e-06\t1.6689300537109375e-06\n",
      "\t\t  0.0  0.0  0.0  0.0  0.0\n",
      "250\t0.002148466110229492\t5.144119262695312e-05\t0.0002492237091064453\t0.0012241744995117188\t0.002525949478149414\n",
      "\t\t  0.16  0.16  0.16  0.16  0.16\n",
      "500\t0.007738122940063477\t7.838249206542969e-05\t0.0007819461822509765\t0.0022533607482910158\t0.004577112197875976\n",
      "\t\t  0.213333  0.213333  0.213333  0.213333  0.213333\n",
      "750\t0.019317550659179686\t0.00012740135192871094\t0.0016937255859375\t0.0037677383422851565\t0.007757015228271484\n",
      "\t\t  0.26  0.26  0.26  0.26  0.26\n",
      "1000\t0.03134757995605469\t0.0001519775390625\t0.002904958724975586\t0.004782199859619141\t0.009877443313598633\n",
      "\t\t  0.296  0.296  0.296  0.296  0.296\n",
      "1250\t0.04826801300048828\t0.00018276214599609374\t0.004197874069213867\t0.007006654739379883\t0.01220062255859375\n",
      "\t\t  0.32  0.32  0.32  0.32  0.32\n",
      "1500\t0.07049726486206055\t0.000235137939453125\t0.006618127822875976\t0.008841218948364258\t0.01609407424926758\n",
      "\t\t  0.325714  0.325714  0.325714  0.325714  0.325714\n",
      "1750\t0.08887992858886719\t0.0002599143981933594\t0.008318090438842773\t0.010435171127319336\t0.018693246841430665\n",
      "\t\t  0.33  0.33  0.33  0.33  0.33\n",
      "2000\t0.12543679237365724\t0.0002922534942626953\t0.010717601776123046\t0.010399761199951172\t0.02223989486694336\n",
      "\t\t  0.328889  0.328889  0.328889  0.328889  0.328889\n",
      "2250\t0.14415929794311524\t0.0003294181823730469\t0.013616981506347657\t0.012887887954711914\t0.02521632194519043\n",
      "\t\t  0.332  0.332  0.332  0.332  0.332\n",
      "2500\t0.14191646575927735\t0.0003324604034423828\t0.014687023162841796\t0.012639198303222656\t0.027315549850463867\n",
      "\t\t  0.349091  0.349091  0.349091  0.349091  0.349091\n",
      "2750\t0.24783570289611817\t0.0004452133178710937\t0.022060413360595704\t0.016405820846557617\t0.03551423072814942\n",
      "\t\t  0.35  0.35  0.35  0.35  0.35\n",
      "3000\t0.2978609752655029\t0.0005313777923583985\t0.028868770599365233\t0.02076517105102539\t0.04101642608642578\n",
      "\t\t  0.350769  0.350769  0.350769  0.350769  0.350769\n",
      "3250\t0.3163586616516113\t0.0005283832550048828\t0.029373331069946287\t0.02196462631225586\t0.03966418266296387\n",
      "\t\t  0.354286  0.354286  0.354286  0.354286  0.354286\n",
      "3500\t0.3944541358947754\t0.0005336666107177735\t0.0322386646270752\t0.020992813110351564\t0.04087580680847168\n",
      "\t\t  0.352  0.352  0.352  0.352  0.352\n",
      "3750\t0.41692214012145995\t0.0005177879333496094\t0.033251380920410155\t0.021008100509643555\t0.042510766983032224\n",
      "\t\t  0.3625  0.3625  0.3625  0.3625  0.3625\n",
      "4000\t0.5017767333984375\t0.0005998802185058594\t0.04394073486328125\t0.024978561401367186\t0.0515278434753418\n",
      "\t\t  0.362353  0.362353  0.362353  0.362353  0.362353\n",
      "4250\t0.5806931018829345\t0.0006586933135986329\t0.0512923526763916\t0.029235095977783204\t0.05305098533630371\n",
      "\t\t  0.355556  0.355556  0.355556  0.355556  0.355556\n",
      "4500\t0.6566379070281982\t0.0006711578369140625\t0.0536777400970459\t0.02891514778137207\t0.05750879287719726\n",
      "\t\t  0.362105  0.362105  0.362105  0.362105  0.36\n",
      "4750\t0.5703709602355957\t0.0006066131591796875\t0.047089576721191406\t0.025816068649291993\t0.04993880271911621\n",
      "\t\t  0.374  0.374  0.374  0.374  0.372\n",
      "5000\t0.7563493442535401\t0.0007768535614013672\t0.0709260082244873\t0.03589420318603516\t0.06552373886108398\n",
      "\t\t  0.375238  0.375238  0.375238  0.375238  0.373333\n",
      "5250\t0.9067646312713623\t0.0008374500274658203\t0.08106375694274902\t0.0383699893951416\t0.07461287498474121\n",
      "\t\t  0.372727  0.372727  0.372727  0.372727  0.370909\n",
      "5500\t0.9545986747741699\t0.0009055805206298829\t0.08586050033569335\t0.03563034057617188\t0.07405350685119629\n",
      "\t\t  0.375652  0.375652  0.375652  0.375652  0.373913\n",
      "5750\t1.0166277503967285\t0.0008620262145996094\t0.08913653373718261\t0.03648646354675293\t0.07136309623718262\n",
      "\t\t  0.376667  0.376667  0.376667  0.376667  0.375\n",
      "6000\t0.9876995182037354\t0.0008794689178466797\t0.08944784164428711\t0.03883572578430176\t0.07613546371459962\n",
      "\t\t  0.3808  0.3808  0.3808  0.3808  0.3792\n",
      "6250\t1.0341107082366943\t0.0009334850311279297\t0.10078779220581055\t0.04036794662475586\t0.08474332809448243\n",
      "\t\t  0.386154  0.386154  0.386154  0.386154  0.383077\n",
      "6500\t1.3155963039398193\t0.0009929561614990235\t0.11127820014953613\t0.04400229454040527\t0.08301787376403809\n",
      "\t\t  0.385185  0.385185  0.385185  0.385185  0.382222\n",
      "6750\t1.1798012256622314\t0.0009375476837158203\t0.10955399513244629\t0.04266481399536133\t0.08720327377319335\n",
      "\t\t  0.39  0.39  0.39  0.39  0.385714\n",
      "7000\t1.6356809902191163\t0.0011359405517578124\t0.1434715461730957\t0.05256658554077148\t0.09979619026184082\n",
      "\t\t  0.387586  0.387586  0.387586  0.387586  0.383448\n",
      "7250\t1.6518349647521973\t0.0011556339263916015\t0.14684467315673827\t0.05384163856506348\t0.09856939315795898\n",
      "\t\t  0.385333  0.385333  0.385333  0.385333  0.381333\n",
      "7500\t1.7459774971008302\t0.0012096691131591797\t0.16188178062438965\t0.053277692794799804\t0.1072426700592041\n",
      "\t\t  0.384516  0.384516  0.384516  0.384516  0.380645\n",
      "7750\t1.9986959648132325\t0.0012459468841552735\t0.17606594085693358\t0.061562147140502926\t0.10822957038879394\n",
      "\t\t  0.38  0.38  0.38  0.38  0.37625\n",
      "8000\t2.1419241428375244\t0.00133453369140625\t0.18468278884887696\t0.06058371543884277\t0.11308583259582519\n",
      "\t\t  0.380606  0.380606  0.380606  0.380606  0.37697\n",
      "8250\t1.9462800121307373\t0.0012294960021972657\t0.1801810646057129\t0.05670970916748047\t0.11185168266296387\n",
      "\t\t  0.381176  0.381176  0.381176  0.381176  0.377647\n",
      "8500\t2.411230058670044\t0.0013231563568115235\t0.21089519500732423\t0.06334635734558106\t0.1239216136932373\n",
      "\t\t  0.377143  0.377143  0.377143  0.377143  0.373714\n",
      "8750\t2.35088680267334\t0.0012838363647460938\t0.2008867835998535\t0.0585176944732666\t0.12141281127929687\n",
      "\t\t  0.377778  0.377778  0.377778  0.377778  0.374444\n",
      "9000\t2.8609728050231933\t0.0016679954528808594\t0.25817216873168947\t0.08064848899841309\t0.15113600730895996\n",
      "\t\t  0.378378  0.378378  0.378378  0.378378  0.375135\n",
      "9250\t2.6874032497406004\t0.0015651035308837892\t0.2576871109008789\t0.07322476387023925\t0.1418312644958496\n",
      "\t\t  0.378947  0.378947  0.378947  0.378947  0.375789\n",
      "9500\t2.712475881576538\t0.0015375137329101563\t0.24918070793151856\t0.06864501953125\t0.13941534996032715\n",
      "\t\t  0.379487  0.379487  0.379487  0.379487  0.37641\n",
      "9750\t2.9878946018218993\t0.0015518856048583984\t0.2705980110168457\t0.07216483116149902\t0.14669984817504883\n",
      "\t\t  0.379  0.379  0.379  0.379  0.376\n",
      "10000\t3.2825598335266113\t0.0016265869140625\t0.28020424842834474\t0.073691987991333\t0.1470265007019043\n",
      "\t\t  0.379512  0.379512  0.379512  0.379512  0.376585\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_529681/3080638617.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     35\u001b[0m         \u001b[0mstart\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 36\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnatmatch_brute_force\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     37\u001b[0m             \u001b[0mmatches_brute_force\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m         \u001b[0mruntime_brute_force\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/tmp/ipykernel_529681/922911526.py\u001b[0m in \u001b[0;36mnatmatch_brute_force\u001b[0;34m(x, y)\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m             \u001b[0;32mif\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import time\n",
    "import random\n",
    "\n",
    "init = 250\n",
    "step = 250\n",
    "nmax = 12000\n",
    "repetitions = 25\n",
    "\n",
    "perf_brute_force = {}\n",
    "perf_dict = {}\n",
    "perf_dynarray = {}\n",
    "perf_BST = {}\n",
    "perf_BBST = {}\n",
    "random.seed()\n",
    "    \n",
    "iterations = 0\n",
    "matches_brute_force = 0\n",
    "matches_dict = 0\n",
    "matches_dynarray = 0\n",
    "matches_BST = 0\n",
    "matches_BBST = 0\n",
    "\n",
    "for n in range(0, nmax+1, step):\n",
    "    iterations += 1\n",
    "    \n",
    "    runtime_brute_force = 0.0\n",
    "    runtime_dict = 0.0\n",
    "    runtime_dynarray = 0.0\n",
    "    runtime_BST = 0.0\n",
    "    runtime_BBST = 0.0\n",
    "    \n",
    "    for i in range(repetitions):\n",
    "        test_list = [random.randrange(n*n) for j in range(n)]\n",
    "        \n",
    "        start = time.time()\n",
    "        if len(natmatch_brute_force(test_list, n*n)) > 0:\n",
    "            matches_brute_force += 1\n",
    "        runtime_brute_force += time.time() - start\n",
    "        \n",
    "        start = time.time()\n",
    "        if len(natmatch_dict(test_list, n*n)) > 0:\n",
    "            matches_dict += 1\n",
    "        runtime_dict += time.time() - start\n",
    "        \n",
    "        start = time.time()\n",
    "        if len(natmatch_dynarray(test_list, n*n)) > 0:\n",
    "            matches_dynarray += 1\n",
    "        runtime_dynarray += time.time() - start\n",
    "        \n",
    "        start = time.time()\n",
    "        if len(natmatch_BST(test_list, n*n)) > 0:\n",
    "            matches_BST += 1\n",
    "        runtime_BST += time.time() - start\n",
    "        \n",
    "        start = time.time()\n",
    "        if len(natmatch_BBST(test_list, n*n)) > 0:\n",
    "            matches_BBST += 1\n",
    "        runtime_BBST += time.time() - start\n",
    "        \n",
    "    perf_brute_force[n] = runtime_brute_force / repetitions\n",
    "    perf_dict[n] = runtime_dict / repetitions\n",
    "    perf_dynarray[n] = runtime_dynarray / repetitions\n",
    "    perf_BST[n] = runtime_BST / repetitions\n",
    "    perf_BBST[n] = runtime_BBST / repetitions\n",
    "    \n",
    "    print(n, perf_brute_force[n], perf_dict[n], perf_dynarray[n], perf_BST[n], perf_BBST[n], sep='\\t')\n",
    "    print(\"\\t\\t\", round(matches_brute_force/(iterations*repetitions), 6), \\\n",
    "          round(matches_dict/(iterations*repetitions), 6), \\\n",
    "          round(matches_dynarray/(iterations*repetitions), 6), \\\n",
    "          round(matches_BST/(iterations*repetitions), 6), \\\n",
    "          round(matches_BBST/(iterations*repetitions), 6), sep=\"  \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "090b54fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='input list size', ylabel='average runtime in seconds'>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sbn\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "keylist_brute_force = list(perf_brute_force.keys())\n",
    "vallist_brute_force = list(perf_brute_force.values())\n",
    "\n",
    "keylist_dict = list(perf_dict.keys())\n",
    "vallist_dict = list(perf_dict.values())\n",
    "\n",
    "keylist_dynarray = list(perf_dynarray.keys())\n",
    "vallist_dynarray = list(perf_dynarray.values())\n",
    "\n",
    "keylist_BST = list(perf_BST.keys())\n",
    "vallist_BST = list(perf_BST.values())\n",
    "\n",
    "keylist_BBST = list(perf_BBST.keys())\n",
    "vallist_BBST = list(perf_BBST.values())\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fig.set_size_inches(15, 9)\n",
    "plt.xticks(fontsize=18, color=\"#322300\")\n",
    "plt.yticks(fontsize=18, color=\"#322300\")\n",
    "ax.set_xlabel(\"input list size\", fontsize=24, color=\"#322300\")\n",
    "ax.set_ylabel(\"average runtime in seconds\", fontsize=24, color=\"#322300\")\n",
    "ax.set_yscale('log')\n",
    "\n",
    "sbn.regplot(x=keylist_brute_force, y=vallist_brute_force, \\\n",
    "            color='#f03010', order=2, scatter_kws={'s':2})  # red for brute force\n",
    "sbn.regplot(x=keylist_dict, y=vallist_dict, color='#e07000', \\\n",
    "            order=1, scatter_kws={'s':2})  # orange for dict\n",
    "sbn.regplot(x=keylist_dynarray, y=vallist_dynarray, \\\n",
    "            color='#005528', order=1, scatter_kws={'s':2})  # green for Python list (dyn. array)\n",
    "sbn.regplot(x=keylist_BST, y=vallist_BST, color='#002855', \\\n",
    "            order=1, scatter_kws={'s':2})  # blue for binary search tree without balancing\n",
    "sbn.regplot(x=keylist_BBST, y=vallist_BBST, color='#322300', \\\n",
    "            order=1, scatter_kws={'s':2})  # black for balanced binary search tree "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28329156",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}