linked_list_implementation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a7c63d0e",
   "metadata": {},
   "source": [
    "A linked list is a sequence of data elements, which are connected together via links. Each data element contains a connection to another data element in form of a pointer. Python does not have linked lists in its standard library. We implement the concept of linked lists using the concept of nodes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be826360",
   "metadata": {},
   "source": [
    "Advantages of Linked Lists over arrays:\n",
    "    \n",
    "- Ease of Insertion/Deletion.\n",
    "\n",
    "Drawbacks of Linked Lists:\n",
    "\n",
    "- Random access is not allowed. We have to access elements sequentially starting from the first node(head node). So we cannot do search with linked lists efficiently with its default implementation. \n",
    "- Extra memory space for a pointer is required with each element of the list. \n",
    "- Direct access to an element is not possible in a linked list as in an array by index.\n",
    "- Not cache friendly. Since array elements are contiguous locations, there is locality of reference which is not there in case of linked lists.\n",
    "- It takes a lot of time in traversing and changing the pointers.\n",
    "- Reverse traversing is not possible in singly linked lists.\n",
    "- It will be confusing when we work with pointers.\n",
    "\n",
    "- Searching an element is costly and requires O(n) time complexity.\n",
    "- Sorting of linked list is very complex and costly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ad6dc7",
   "metadata": {},
   "source": [
    "# Creation of Linked List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "251fe238",
   "metadata": {},
   "source": [
    "A linked list is represented by a pointer to the first node of the linked list. The first node is called the head of the linked list. If the linked list is empty, then the value of the head points to NULL. \n",
    "\n",
    "Each node in a list consists of at least two parts: \n",
    "\n",
    "- A Data Item (we can store integer, strings, or any type of data).\n",
    "- Pointer (Or Reference) to the next node (connects one node to another) or An address of another node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "54186291",
   "metadata": {},
   "outputs": [],
   "source": [
    "# camelcascading\n",
    "\n",
    "#initialization, assignment: whenever we define a variable for first time, it is initizalization \n",
    "# whenever we define a variable  apartfrom first time, it is assignment "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e1e113c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.next = None\n",
    "\n",
    "class LinkedList:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "ll = LinkedList()\n",
    "ll.head = Node(10)\n",
    "n2 = Node(20)\n",
    "n3 = Node(30)\n",
    "\n",
    "ll.head.next = n2\n",
    "n2.next = n3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "933a081d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bb08ef50",
   "metadata": {},
   "source": [
    "# Traversing a Linked List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c4aa007",
   "metadata": {},
   "source": [
    "Singly linked lists can be traversed in only forward direction starting form the first data element. We simply print the value of the next data element by assigning the pointer of the next node to the current data element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5dd98eca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.next = None\n",
    "\n",
    "class LinkedList:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def llistprint(self):\n",
    "        printval = self.head\n",
    "        \n",
    "        while printval is not None:\n",
    "            print(printval.data)\n",
    "            printval = printval.next\n",
    "            \n",
    "        \n",
    "ll = LinkedList()\n",
    "ll.head = Node(10)\n",
    "n2 = Node(20)\n",
    "n3 = Node(30)\n",
    "\n",
    "ll.head.next = n2\n",
    "n2.next = n3\n",
    "\n",
    "ll.llistprint()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbbbf056",
   "metadata": {},
   "source": [
    "# INSERTION IN LINKED LIST"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41aad5e6",
   "metadata": {},
   "source": [
    "Inserting element in the linked list involves reassigning the pointers from the existing nodes to the newly inserted node. Depending on whether the new data element is getting inserted at the beginning or at the middle or at the end of the linked list, we have the below scenarios."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c469a3a7",
   "metadata": {},
   "source": [
    "# Inserting at the Beginning"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "85848a55",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2307802c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial linked list:\n",
      "10\n",
      "20\n",
      "30\n",
      "after insertion at beginning:\n",
      "5\n",
      "10\n",
      "20\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.next = None\n",
    "\n",
    "class LinkedList:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def llistprint(self):\n",
    "        printval = self.head\n",
    "        \n",
    "        while printval is not None:\n",
    "            print(printval.data)\n",
    "            printval = printval.next\n",
    "            \n",
    "    def insert_at_beginning(self, new_data):\n",
    "        new_node = Node(new_data)\n",
    "        new_node.next = self.head\n",
    "        self.head = new_node\n",
    "        \n",
    "        \n",
    "ll = LinkedList()\n",
    "ll.head = Node(10)\n",
    "n2 = Node(20)\n",
    "n3 = Node(30)\n",
    "\n",
    "ll.head.next = n2\n",
    "n2.next = n3\n",
    "\n",
    "print(\"initial linked list:\")\n",
    "ll.llistprint()\n",
    "\n",
    "print(\"after insertion at beginning:\")\n",
    "ll.insert_at_beginning(5)\n",
    "ll.llistprint()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37336722",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a958af5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "17e0cff6",
   "metadata": {},
   "source": [
    "# Inserting at the end"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "3f328dfd",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "85488798",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial linked list:\n",
      "10\n",
      "20\n",
      "30\n",
      "after insertion at beginning:\n",
      "5\n",
      "10\n",
      "20\n",
      "30\n",
      "after inserrtion at end:\n",
      "5\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.next = None\n",
    "\n",
    "class LinkedList:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def llistprint(self):\n",
    "        printval = self.head\n",
    "        \n",
    "        while printval is not None:\n",
    "            print(printval.data)\n",
    "            printval = printval.next\n",
    "            \n",
    "    def insert_at_beginning(self, new_data):\n",
    "        new_node = Node(new_data)\n",
    "        new_node.next = self.head\n",
    "        self.head = new_node\n",
    "        \n",
    "    def insert_at_end(self, new_data):\n",
    "        # creating a new node\n",
    "        new_node = Node(new_data)\n",
    "        \n",
    "        # check if linked list is empty\n",
    "        if self.head is None:\n",
    "            self.head = new_node\n",
    "        \n",
    "        # traverse through the entire linked list to reach to the end of linked list\n",
    "        # b'coz random accessing of elements isn't possible in linked list\n",
    "        curr_last_node = self.head\n",
    "        \n",
    "        # traversal of linked list, the loop will terminate when it reaches to the end of linked list\n",
    "        while(curr_last_node.next):\n",
    "            curr_last_node = curr_last_node.next\n",
    "            \n",
    "        # create linkage, i.e., updating the last node pointer of linked list to point to new node\n",
    "        curr_last_node.next = new_node\n",
    "        \n",
    "        \n",
    "ll = LinkedList()\n",
    "ll.head = Node(10)\n",
    "n2 = Node(20)\n",
    "n3 = Node(30)\n",
    "\n",
    "ll.head.next = n2\n",
    "n2.next = n3\n",
    "\n",
    "print(\"initial linked list:\")\n",
    "ll.llistprint()\n",
    "\n",
    "print(\"after insertion at beginning:\")\n",
    "ll.insert_at_beginning(5)\n",
    "ll.llistprint()\n",
    "\n",
    "ll.insert_at_end(40)\n",
    "print(\"after inserrtion at end:\")\n",
    "ll.llistprint()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "565d7ad1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50bef07e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6448dd94",
   "metadata": {},
   "source": [
    "# Inserting in between"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "5be0e53c",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "037a175b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial linked list:\n",
      "10\n",
      "20\n",
      "30\n",
      "after insertion at beginning:\n",
      "5\n",
      "10\n",
      "20\n",
      "30\n",
      "after inserrtion at end:\n",
      "5\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "after insertion in between: \n",
      "5\n",
      "10\n",
      "20\n",
      "25\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.next = None\n",
    "\n",
    "class LinkedList:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def llistprint(self):\n",
    "        printval = self.head\n",
    "        \n",
    "        while printval is not None:\n",
    "            print(printval.data)\n",
    "            printval = printval.next\n",
    "            \n",
    "    def insert_at_beginning(self, new_data):\n",
    "        new_node = Node(new_data)\n",
    "        new_node.next = self.head\n",
    "        self.head = new_node\n",
    "        \n",
    "    def insert_at_end(self, new_data):\n",
    "        # creating a new node\n",
    "        new_node = Node(new_data)\n",
    "        \n",
    "        # check if linked list is empty\n",
    "        if self.head is None:\n",
    "            self.head = new_node\n",
    "        \n",
    "        # traverse through the entire linked list to reach to the end of linked list\n",
    "        # b'coz random accessing of elements isn't possible in linked list\n",
    "        curr_last_node = self.head\n",
    "        \n",
    "        # traversal of linked list, the loop will terminate when it reaches to the end of linked list\n",
    "        while(curr_last_node.next):\n",
    "            curr_last_node = curr_last_node.next\n",
    "            \n",
    "        # create linkage, i.e., updating the last node pointer of linked list to point to new node\n",
    "        curr_last_node.next = new_node\n",
    "        \n",
    "    def insert_at_between(self, new_data, prev_node):\n",
    "        # param: prev_node tells that after which node insertion is to be done\n",
    "        \n",
    "        if prev_node is None:\n",
    "            print(\"The node is absent\")\n",
    "            return\n",
    "        \n",
    "        # create new node\n",
    "        new_node = Node(new_data)\n",
    "        # creating connections/linkages\n",
    "        new_node.next = prev_node.next\n",
    "        prev_node.next = new_node\n",
    "        \n",
    "        \n",
    "        \n",
    "ll = LinkedList()\n",
    "ll.head = Node(10)\n",
    "n2 = Node(20)\n",
    "n3 = Node(30)\n",
    "\n",
    "ll.head.next = n2\n",
    "n2.next = n3\n",
    "\n",
    "print(\"initial linked list:\")\n",
    "ll.llistprint()\n",
    "\n",
    "print(\"after insertion at beginning:\")\n",
    "ll.insert_at_beginning(5)\n",
    "ll.llistprint()\n",
    "\n",
    "ll.insert_at_end(40)\n",
    "print(\"after inserrtion at end:\")\n",
    "ll.llistprint()\n",
    "\n",
    "ll.insert_at_between(25, (ll.head.next).next)\n",
    "print(\"after insertion in between: \")\n",
    "ll.llistprint()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7f27e00",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10cbbc50",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "97a8db78",
   "metadata": {},
   "source": [
    "# REMOVING AN ITEM"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86d6c663",
   "metadata": {},
   "source": [
    "We can remove an existing node using the key for that node. In the below program we locate the previous node of the node which is to be deleted.Then, point the next pointer of this node to the next node of the node to be deleted."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "3915415e",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0d742df9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial linked list:\n",
      "10\n",
      "20\n",
      "30\n",
      "after insertion at beginning:\n",
      "5\n",
      "10\n",
      "20\n",
      "30\n",
      "after inserrtion at end:\n",
      "5\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "after insertion in between: \n",
      "5\n",
      "10\n",
      "20\n",
      "25\n",
      "30\n",
      "40\n",
      "after deletion:\n",
      "5\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.next = None\n",
    "\n",
    "class LinkedList:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def llistprint(self):\n",
    "        printval = self.head\n",
    "        \n",
    "        while printval is not None:\n",
    "            print(printval.data)\n",
    "            printval = printval.next\n",
    "            \n",
    "    def insert_at_beginning(self, new_data):\n",
    "        new_node = Node(new_data)\n",
    "        new_node.next = self.head\n",
    "        self.head = new_node\n",
    "        \n",
    "    def insert_at_end(self, new_data):\n",
    "        # creating a new node\n",
    "        new_node = Node(new_data)\n",
    "        \n",
    "        # check if linked list is empty\n",
    "        if self.head is None:\n",
    "            self.head = new_node\n",
    "        \n",
    "        # traverse through the entire linked list to reach to the end of linked list\n",
    "        # b'coz random accessing of elements isn't possible in linked list\n",
    "        curr_last_node = self.head\n",
    "        \n",
    "        # traversal of linked list, the loop will terminate when it reaches to the end of linked list\n",
    "        while(curr_last_node.next):\n",
    "            curr_last_node = curr_last_node.next\n",
    "            \n",
    "        # create linkage, i.e., updating the last node pointer of linked list to point to new node\n",
    "        curr_last_node.next = new_node\n",
    "        \n",
    "    def insert_at_between(self, new_data, prev_node):\n",
    "        # param: prev_node tells that after which node insertion is to be done\n",
    "        \n",
    "        if prev_node is None:\n",
    "            print(\"The node is absent\")\n",
    "            return\n",
    "        \n",
    "        # create new node\n",
    "        new_node = Node(new_data)\n",
    "        # creating connections/linkages\n",
    "        new_node.next = prev_node.next\n",
    "        prev_node.next = new_node\n",
    "        \n",
    "        \n",
    "    def delete_node(self, key):\n",
    "        \n",
    "        # creating variable for traversal through linked list\n",
    "        temp = self.head\n",
    "        \n",
    "        # if head node itself holds the key to be deleted\n",
    "        if(temp is not None):\n",
    "            if (temp.data == key):\n",
    "                self.head = temp.next\n",
    "                temp = None\n",
    "                return\n",
    "            \n",
    "        # search for the key to be deleted, keep track of the previous node(create anothervar.: prev) as we need to change prev.next\n",
    "        while(temp is not None):\n",
    "            if temp.data == key:\n",
    "                break\n",
    "            # creating 'prev' var. to keep track of the previous node\n",
    "            prev = temp\n",
    "            temp = temp.next\n",
    "            \n",
    "        # if key wasn't present in the linked list\n",
    "        if(temp == None):\n",
    "            return\n",
    "        \n",
    "        #  link the node from linked list\n",
    "        prev.next = temp.next\n",
    "        # writing below line to remove the key node connection from linked list\n",
    "        temp = None\n",
    "        \n",
    "        \n",
    "ll = LinkedList()\n",
    "ll.head = Node(10)\n",
    "n2 = Node(20)\n",
    "n3 = Node(30)\n",
    "\n",
    "ll.head.next = n2\n",
    "n2.next = n3\n",
    "\n",
    "print(\"initial linked list:\")\n",
    "ll.llistprint()\n",
    "\n",
    "print(\"after insertion at beginning:\")\n",
    "ll.insert_at_beginning(5)\n",
    "ll.llistprint()\n",
    "\n",
    "ll.insert_at_end(40)\n",
    "print(\"after inserrtion at end:\")\n",
    "ll.llistprint()\n",
    "\n",
    "ll.insert_at_between(25, (ll.head.next).next)\n",
    "print(\"after insertion in between: \")\n",
    "ll.llistprint()\n",
    "\n",
    "ll.delete_node(25)\n",
    "print(\"after deletion:\")\n",
    "ll.llistprint()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9254f746",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}