Randomization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4e7d9279",
   "metadata": {},
   "source": [
    "# Treap Data Structure\n",
    "\n",
    "The Treap (Tree + Heap) is a randomized binary search tree that combines the properties of a binary search tree and a heap. It maintains the binary search tree property with respect to the keys of the nodes and the heap property with respect to the priorities assigned to the nodes.\n",
    "\n",
    "## Structure\n",
    "\n",
    "A Treap is made up of nodes, each containing a key-value pair and a priority. The key follows the binary search tree property, where the keys in the left subtree are smaller than the key at the current node, and the keys in the right subtree are greater. The priorities are chosen randomly and follow the heap property, where the priority of a node is greater than or equal to the priorities of its children.\n",
    "\n",
    "## Operations\n",
    "\n",
    "### Insertion\n",
    "\n",
    "To insert a new element into the Treap, we first perform a standard binary search tree insertion based on the key. After insertion, we maintain the heap property by performing rotations to ensure that the priorities are in the correct order.\n",
    "\n",
    "### Deletion\n",
    "\n",
    "Deleting an element from the Treap involves finding the node with the given key and removing it. After deletion, we ensure that the tree remains a valid Treap by performing rotations to maintain the heap property.\n",
    "\n",
    "### Search\n",
    "\n",
    "Searching for an element in the Treap is similar to searching in a binary search tree. We start at the root and recursively search the left or right subtree based on the comparison of the key with the current node's key.\n",
    "\n",
    "## Advantages\n",
    "\n",
    "- The Treap combines the advantages of both binary search trees and heaps, providing efficient search, insertion, and deletion operations.\n",
    "- Its randomized nature helps in balancing the tree, resulting in better performance compared to deterministic binary search trees in certain scenarios.\n",
    "- It is relatively simple to implement and does not require complex balancing algorithms.\n",
    "\n",
    "## Applications\n",
    "\n",
    "- Treaps are commonly used in scenarios where both search and priority-based operations are required, such as priority queues.\n",
    "- They are also used in randomized algorithms and data structures, where the randomization properties of Treaps can be beneficial.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bd411473",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random # To generate Random Numbers\n",
    "import matplotlib.pyplot as plt #To plot the number of operations vs. input size\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ecd9e3e",
   "metadata": {},
   "source": [
    "# Binary Search Tree (BST) Implementation\n",
    "\n",
    "This code provides a Python implementation of a Binary Search Tree (BST) and related operations such as insertion, search, and counting operations.\n",
    "\n",
    "## TreeNode Class\n",
    "\n",
    "The `TreeNode` class represents a node in the binary search tree. Each node contains a key value (`val`) and references to its left and right children (`left` and `right`).\n",
    "\n",
    "## BST Class\n",
    "\n",
    "The `BST` class represents the Binary Search Tree data structure. It has the following methods:\n",
    "\n",
    "### Constructor\n",
    "\n",
    "- `__init__(self)`: Initializes an empty BST with a null root.\n",
    "\n",
    "### Insertion\n",
    "\n",
    "- `insert(self, root, key)`: Inserts a new node with the given key into the BST. If the root is null, it creates a new node with the key. Otherwise, it recursively inserts the key into the left subtree if it's less than the root's value or into the right subtree if it's greater.\n",
    "\n",
    "### Search\n",
    "\n",
    "- `search(self, root, key)`: Searches for a node with the given key in the BST. It returns the node if found, otherwise returns None.\n",
    "\n",
    "### Count Operations\n",
    "\n",
    "- `count_operations(self, root, key)`: Counts the number of operations required to find a node with the given key in the BST. It traverses the tree from the root to the target node, counting each operation performed.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "56c017f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TreeNode:\n",
    "    def __init__(self, key):\n",
    "        self.val = key\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "\n",
    "class BST:\n",
    "    def __init__(self):\n",
    "        self.root = None\n",
    "\n",
    "    def insert(self, root, key):\n",
    "        if root is None:\n",
    "            return TreeNode(key)\n",
    "        else:\n",
    "            if root.val < key:\n",
    "                root.right = self.insert(root.right, key)\n",
    "            else:\n",
    "                root.left = self.insert(root.left, key)\n",
    "        return root\n",
    "\n",
    "    def search(self, root, key):\n",
    "        if root is None or root.val == key:\n",
    "            return root\n",
    "        if root.val < key:\n",
    "            return self.search(root.right, key)\n",
    "        return self.search(root.left, key)\n",
    "\n",
    "    def count_operations(self, root, key):\n",
    "        count = 0\n",
    "        while root:\n",
    "            count += 1\n",
    "            if root.val == key:\n",
    "                return count\n",
    "            elif root.val < key:\n",
    "                root = root.right\n",
    "            else:\n",
    "                root = root.left\n",
    "        return count\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3cafd3c",
   "metadata": {},
   "source": [
    "# Treap Data Structure Implementation\n",
    "\n",
    "This code provides a Python implementation of a Treap data structure, which is a combination of a binary search tree (BST) and a heap.\n",
    "\n",
    "## TreapNode Class\n",
    "\n",
    "The `TreapNode` class represents a node in the Treap. Each node contains a key-value pair (`key` and `priority`) and references to its left and right children (`left` and `right`).\n",
    "\n",
    "## Treap Class\n",
    "\n",
    "The `Treap` class represents the Treap data structure. It has the following methods:\n",
    "\n",
    "### Constructor\n",
    "\n",
    "- `__init__(self)`: Initializes an empty Treap with a null root.\n",
    "\n",
    "### Rotations\n",
    "\n",
    "- `rotate_right(self, y)`: Performs a right rotation around the given node `y`.\n",
    "- `rotate_left(self, x)`: Performs a left rotation around the given node `x`.\n",
    "\n",
    "### Insertion\n",
    "\n",
    "- `insert(self, root, key, priority)`: Inserts a new node with the given key and priority into the Treap. It maintains the heap property by performing rotations as necessary during insertion.\n",
    "\n",
    "### Search\n",
    "\n",
    "- `search(self, root, key)`: Searches for a node with the given key in the Treap. It returns the node if found, otherwise returns None.\n",
    "\n",
    "### Count Search Operations\n",
    "\n",
    "- `treap_search_operations(self, key)`: Counts the number of operations required to find a node with the given key in the Treap. It traverses the tree from the root to the target node, counting each operation performed.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "792535ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TreapNode:\n",
    "    def __init__(self, key, priority):\n",
    "        self.key = key\n",
    "        self.priority = priority\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "\n",
    "class Treap:\n",
    "    def __init__(self):\n",
    "        self.root = None\n",
    "\n",
    "    def rotate_right(self, y):\n",
    "        x = y.left\n",
    "        y.left = x.right\n",
    "        x.right = y\n",
    "        return x\n",
    "\n",
    "    def rotate_left(self, x):\n",
    "        y = x.right\n",
    "        x.right = y.left\n",
    "        y.left = x\n",
    "        return y\n",
    "\n",
    "    def insert(self, root, key, priority):\n",
    "        if root is None:\n",
    "            return TreapNode(key, priority)\n",
    "        \n",
    "        if key <= root.key:\n",
    "            root.left = self.insert(root.left, key, priority)\n",
    "            if root.left.priority > root.priority:\n",
    "                root = self.rotate_right(root)\n",
    "        else:\n",
    "            root.right = self.insert(root.right, key, priority)\n",
    "            if root.right.priority > root.priority:\n",
    "                root = self.rotate_left(root)\n",
    "        \n",
    "        return root\n",
    "\n",
    "    def search(self, root, key):\n",
    "        if root is None or root.key == key:\n",
    "            return root\n",
    "        if key < root.key:\n",
    "            return self.search(root.left, key)\n",
    "        return self.search(root.right, key)\n",
    "    def treap_search_operations(self, key):\n",
    "        current = self.root\n",
    "        count = 0\n",
    "        while current:\n",
    "            count += 1\n",
    "            if current.key == key:\n",
    "                return count\n",
    "            elif key < current.key:\n",
    "                current = current.left\n",
    "            else:\n",
    "                current = current.right\n",
    "        return count\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7a22b23",
   "metadata": {},
   "source": [
    "# BST Experiment Function\n",
    "\n",
    "The `bst_experiment` function performs an experiment on a Binary Search Tree (BST). It takes two parameters: `size`, which represents the size of the tree, and `generate_tree_func`, a function that generates a BST with the given size. The function returns the average number of operations required to search for keys in the BST.\n",
    "\n",
    "## Parameters:\n",
    "\n",
    "- `size`: The size of the binary search tree.\n",
    "- `generate_tree_func`: A function that generates a binary search tree with the given size and returns the BST instance and its root node.\n",
    "\n",
    "## Explanation:\n",
    "\n",
    "1. Initialize the total number of operations to 0.\n",
    "2. Generate a binary search tree (`bst`) using the provided `generate_tree_func`.\n",
    "3. Iterate over keys from 1 to `size`.\n",
    "    - For each key, count the number of operations required to search for the key in the BST using the `count_operations` method.\n",
    "    - Add the number of operations to the total operations.\n",
    "4. Calculate the average number of operations by dividing the total operations by the size of the tree.\n",
    "5. Return the average number of operations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e22bc854",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bst_experiment(size, generate_tree_func):\n",
    "    total_operations = 0\n",
    "    bst, root = generate_tree_func(size)\n",
    "    for key in range(1, size + 1):\n",
    "        total_operations += bst.count_operations(root, key)\n",
    "    average_operations = total_operations / size\n",
    "    return average_operations\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b994ce77",
   "metadata": {},
   "source": [
    "# Treap Experiment Function\n",
    "\n",
    "The `treap_experiment` function performs an experiment on a Treap data structure. It takes one parameter: `size`, which represents the size of the Treap. The function returns the average number of operations required to search for keys in the Treap.\n",
    "\n",
    "## Parameters:\n",
    "\n",
    "- `size`: The size of the Treap.\n",
    "\n",
    "## Explanation:\n",
    "\n",
    "1. Initialize the total number of operations to 0.\n",
    "2. Generate a Treap with the given size using the `generate_treap` function.\n",
    "3. Iterate over keys from 1 to `size`.\n",
    "    - For each key, count the number of operations required to search for the key in the Treap using the `treap_search_operations` method.\n",
    "    - Add the number of operations to the total operations.\n",
    "4. Calculate the average number of operations by dividing the total operations by the size of the Treap.\n",
    "5. Return the average number of operations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fae94f69",
   "metadata": {},
   "outputs": [],
   "source": [
    "def treap_experiment(size):\n",
    "    total_operations = 0\n",
    "    treap = generate_treap(size)\n",
    "    for key in range(1, size + 1):\n",
    "        total_operations +=treap.treap_search_operations(key)\n",
    "    average_operations = total_operations / size\n",
    "    return average_operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "701f2f0f",
   "metadata": {},
   "source": [
    "# Generation Functions for Binary Search Trees (BST) and Treaps\n",
    "\n",
    "These functions generate binary search trees (BST) and Treaps for experimental analysis, considering both average and worst-case scenarios.\n",
    "\n",
    "## Generate Average Case Binary Search Tree (BST)\n",
    "\n",
    "The `generate_bst_average_case` function generates a binary search tree in the average-case scenario. It shuffles a list of keys from 1 to `size` and inserts them into the BST. This results in a balanced binary search tree where keys are randomly ordered. \n",
    "\n",
    "## Generate Worst Case Binary Search Tree (BST)\n",
    "\n",
    "The `generate_bst_worst_case` function generates a binary search tree in the worst-case scenario. It inserts keys from 1 to `size` sequentially into the BST, resulting in an unbalanced tree where keys are ordered sequentially.\n",
    "\n",
    "## Generate Worst Case Treap\n",
    "\n",
    "The `generate_treap_worst_case` function generates a Treap in the worst-case scenario. It inserts keys from 1 to `size` sequentially into the Treap, using the key itself as the priority. This results in a Treap where the priorities are not randomized, potentially leading to performance issues in certain scenarios.\n",
    "\n",
    "## Generate Treap\n",
    "\n",
    "The `generate_treap` function generates a Treap for the average-case scenario. It inserts keys from 1 to `size` into the Treap with random priorities. This results in a balanced Treap where keys are inserted randomly with randomized priorities, ensuring better performance in most scenarios.\n",
    "\n",
    "These generation functions allow for the creation of binary search trees and Treaps with varying characteristics, facilitating experimental analysis and performance evaluation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "28a656f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_bst_average_case(size):\n",
    "    bst = BST()\n",
    "    keys = list(range(1, size + 1))\n",
    "    random.shuffle(keys)\n",
    "    root = None\n",
    "    for key in keys:\n",
    "        root = bst.insert(root, key)\n",
    "    return bst, root\n",
    "\n",
    "def generate_bst_worst_case(size):\n",
    "    bst = BST()\n",
    "    root = None\n",
    "    for key in range(1, size + 1):\n",
    "        root = bst.insert(root, key)\n",
    "    return bst, root\n",
    "\n",
    "def generate_treap_worst_case(size):\n",
    "    treap = Treap()\n",
    "    for key in range(1, size + 1):\n",
    "        treap.root = treap.insert(treap.root, key, random.randint(0, 100))  # Using key as priority\n",
    "    return treap\n",
    "\n",
    "def generate_treap(size):\n",
    "    keys = list(range(1, size + 1))\n",
    "    treap = Treap()\n",
    "    for key in range(1, size + 1):\n",
    "        treap.root = treap.insert(treap.root, key, random.randint(0, 100))  # Using key as priority\n",
    "    return treap"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a0897d4",
   "metadata": {},
   "source": [
    "# Experimental Analysis of Binary Search Trees (BST) vs. Treaps\n",
    "\n",
    "In this code snippet, an experimental analysis is conducted to compare the performance of Binary Search Trees (BST) and Treaps under average and worst-case scenarios.\n",
    "\n",
    "## Experiment Setup\n",
    "\n",
    "- The experiment is conducted for tree sizes ranging from 1 to 100 (`max_size = 100`).\n",
    "- Two sets of experiments are performed:\n",
    "  1. Average case experiments: Trees are generated using average-case generation functions.\n",
    "  2. Worst case experiments: Trees are generated using worst-case generation functions.\n",
    "\n",
    "## Data Collection\n",
    "\n",
    "- For each tree size, the average number of operations required for searching keys in both BST and Treap data structures is recorded.\n",
    "- The `bst_experiment` and `treap_experiment` functions are used to conduct the experiments.\n",
    "\n",
    "## Plot\n",
    "\n",
    "- The plot visualizes the average number of operations against the size of the tree for both BST and Treap under average and worst-case scenarios.\n",
    "- Four lines are plotted:\n",
    "  1. BST (Average Case)\n",
    "  2. Treap (Average Case)\n",
    "  3. BST (Worst Case)\n",
    "  4. Treap (Worst Case)\n",
    "\n",
    "## Observations\n",
    "\n",
    "- In the average case, both BST and Treap exhibit relatively similar performance, with the number of operations increasing gradually as the size of the tree grows.\n",
    "- In the worst case, the performance of BST deteriorates significantly as the tree becomes unbalanced, leading to a sharp increase in the number of operations required for searching. On the other hand, Treap maintains relatively stable performance due to its randomized structure, resulting in a more consistent number of operations across different tree sizes.\n",
    "\n",
    "This experimental analysis provides insights into the comparative performance of BST and Treap under different scenarios, aiding in the selection of appropriate data structures for various applications.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e7a2e0d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "max_size = 100\n",
    "sizes = list(range(1, max_size + 1))\n",
    "\n",
    "# Average case experiments\n",
    "bst_average_case_operations = [bst_experiment(size, generate_bst_average_case) for size in sizes]\n",
    "treap_average_case_operations = [treap_experiment(size) for size in sizes]\n",
    "\n",
    "# Worst case experiments\n",
    "bst_worst_case_operations = [bst_experiment(size, generate_bst_worst_case) for size in sizes]\n",
    "treap_worst_case_operations = [treap_experiment(size) for size in sizes]\n",
    "\n",
    "plt.plot(sizes, bst_average_case_operations, label='BST (Average Case)', marker='o')\n",
    "plt.plot(sizes, treap_average_case_operations, label='Treap (Average Case)', marker='o')\n",
    "plt.plot(sizes, bst_worst_case_operations, label='BST (Worst Case)', marker='o')\n",
    "plt.plot(sizes, treap_worst_case_operations, label='Treap (Worst Case)', marker='o')\n",
    "plt.title('BST vs Treap: Size vs Average Number of Operations')\n",
    "plt.xlabel('Size of Tree')\n",
    "plt.ylabel('Average Number of Operations')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b6c432f",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "[1] Seidel, R., & Aragon, C. R. (1996). Randomized search trees. Algorithmica, 16(4-5), 464-497.\n",
    "\n",
    "[2] Goodrich, M. T., Tamassia, R., & Goldwasser, M. H. (n.d.). Data Structures and Algorithms in Python.\n"
   ]
  }
 ],
 "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}