second_largest_node.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "\n",
    "Image(filename=\"secondlarestnode.PNG\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/gif": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename=\"bstexample.gif\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorithm Inorder(tree)\n",
    "   1. Traverse the left subtree, i.e., call Inorder(left-subtree)\n",
    "   2. Visit the root.\n",
    "   3. Traverse the right subtree, i.e., call Inorder(right-subtree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1,2,3,4,5\n",
    "\n",
    "Reverse inorder 5,4,3,2,1\n",
    "\n",
    "Reverse BST with counter print the node counter is 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node(object):\n",
    "    def __init__(self,data):\n",
    "        self.data=data\n",
    "        self.rightChild=None\n",
    "        self.leftChild=None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BinarySearchTree(object):\n",
    "    def __init__(self):\n",
    "        self.root=None\n",
    "    \n",
    "    def insert(self,data):\n",
    "        if not self.root:\n",
    "            self.root=Node(data)\n",
    "        else:\n",
    "            self.insertNode(data,self.root)\n",
    "    \n",
    "    def insertNode(self,data,node):\n",
    "        if data < node.data:\n",
    "            if node.leftChild:\n",
    "                self.insertNode(data,node.leftChild)\n",
    "            else:\n",
    "                node.leftChild=Node(data)\n",
    "        else:\n",
    "            if node.rightChild:\n",
    "                self.insertNode(data,node.rightChild)\n",
    "            else:\n",
    "                node.rightChild=Node(data)\n",
    "    def getMinValue(self):\n",
    "        if self.root:\n",
    "            return self.getMin(self.root)\n",
    "    def getMin(self,node):\n",
    "        if node.leftChild:\n",
    "            return self.getMin(node.leftChild)\n",
    "        return node.data\n",
    "    def getMaxValue(self):\n",
    "        if self.root:\n",
    "            return self.getMax(self.root)\n",
    "    def getMax(self,node):\n",
    "        if node.rightChild:\n",
    "            return self.getMax(node.rightChild)\n",
    "        return node.data\n",
    "    def traverse(self,order):\n",
    "        if self.root:\n",
    "            if order == \"inorder\":\n",
    "                self.traverseInorder(self.root)\n",
    "            elif order == \"preorder\":\n",
    "                self.traversePreorder(self.root)\n",
    "            else:\n",
    "                self.traversePostorder(self.root)\n",
    "    def traverseInorder(self,node):\n",
    "        if node.leftChild:\n",
    "            self.traverseInorder(node.leftChild)\n",
    "        print(node.data)\n",
    "        if node.rightChild:\n",
    "            self.traverseInorder(node.rightChild)\n",
    "    def traversePreorder(self,node):\n",
    "        print(node.data)\n",
    "        if node.leftChild:\n",
    "            self.traverseInorder(node.leftChild)\n",
    "        if node.rightChild:\n",
    "            self.traverseInorder(node.rightChild)\n",
    "    def traversePostorder(self,node):\n",
    "        if node.leftChild:\n",
    "            self.traverseInorder(node.leftChild)\n",
    "        if node.rightChild:\n",
    "            self.traverseInorder(node.rightChild)\n",
    "        print(node.data)\n",
    "    def getsecondlargest(self):\n",
    "        if self.root:\n",
    "            # visited as 0  \n",
    "            c = [0]  \n",
    "            self.fetchsecondlargest(self.root,c)\n",
    "    def fetchsecondlargest(self,node,c):\n",
    "        if node == None or c[0] >= 2:  \n",
    "            return\n",
    "        self.fetchsecondlargest(node.rightChild, c)\n",
    "        c[0]+=1\n",
    "        if c[0] == 2: \n",
    "            print(node.data)\n",
    "            return\n",
    "        self.fetchsecondlargest(node.leftChild, c)\n",
    "    def getkthlargest(self,k):\n",
    "        if self.root:\n",
    "            # visited as 0  \n",
    "            c = [0]  \n",
    "            self.fetchkthlargest(self.root,k,c)\n",
    "    def fetchkthlargest(self,node,k,c):\n",
    "        if node == None or c[0] >= k:  \n",
    "            return\n",
    "        self.fetchkthlargest(node.rightChild,k, c)\n",
    "        c[0]+=1\n",
    "        if c[0] == k: \n",
    "            print(node.data)\n",
    "            return\n",
    "        self.fetchkthlargest(node.leftChild,k, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "bst=BinarySearchTree()\n",
    "bst.insert(10)\n",
    "bst.insert(5)\n",
    "bst.insert(15)\n",
    "bst.insert(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bst.getMaxValue()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bst.getMinValue()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "10\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "bst.traverse(\"inorder\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "5\n",
      "6\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "bst.traverse(\"preorder\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "15\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "bst.traverse(\"postorder\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "bst.getsecondlargest()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "bst.getkthlargest(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "bst.getkthlargest(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Time Complexity O(h) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}