using Python Programming. ### DoublyLinkedList Class Implementation Guide#### Instructions:1. **Implement and Test the DoublyLinkedList Class:** - Implement the class in `lab7_doublyLinkedList.py`. - Include both `Node` and `DoublyLinkedList` class implementations. - Print the output to the screen and save it in the file `lab7_output.txt` for testing purposes.2. **Complexity Analysis:** - Output one line for each method, indicating its complexity: O(1), O(n), or O(n*n).#### Class Overview:##### DoublyLinkedList- **Attributes:** - `+ head: Node` - `+ tail: Node` - `- _len: int`- **Methods:** - `+ DoublyLinkedList()` - `insertAtHead(object item) : void` - `insertAtTail(object item) : void` - `insertAtAfter(object item, Node refNode) : void` - `insertBefore(object item, Node refNode) : void` - `deleteFromHead() : object` - `deleteFromTail() : object` - `deleteAt(Node node2Remove) : object` - `delete(item: object) : void` - `deleteAll(item: object) : void` - `+isEmpty() : boolean` - `+ clear() : void` - `+ __str__() : string` - `+ __len__() : int` - `+ __iter__()` - `+ __getitem__(int index) : object` - `+ __setitem__(int index, object item) : object`##### Node- **Attributes:** - `+ data : object` - `+ prev : Node` - `+ next : Node`- **Methods:** - `+ Node(data, prev, nxt)` - `+ __str__() : string`### Diagram Explanation:The diagram represents the structure of a doubly linked list item and its basic operations. It shows how nodes are connected forward and backward, allowing traversal in both directions. The class includes methods for insertion, deletion, iteration, and checking emptiness, along with complexity notes for each operation.

Python Programming which refers to the one which it is a high-level, general-purpose programming language. Its design which also used to emphasizes code readability with the use of significant indentation. Python which also refers to the one it is dynamically-typed and garbage-collected. It supports multiple programming paradigms, including structured, object-oriented and functional programming.Doubly Linked List (DLL) which contains an extra pointer, that are used for the typically called the previous pointer, together with the next pointer and data which are there in the singly linked list. Advantages of DLL over the singly linked list: A DLL which can be easily traversed in both forward and backward directions. The delete operation in the DLL is more efficient if a pointer to the node which are to be deleted is given. We can easily quickly insert a new node before a given node. The Sample Code for the DLL: Here i would like to implement the some of the functions and methods which are easily used to understand the concept: class Node: def _init_(self, next = None, prev = None, data = None): self. next = next self. prev = prev self. data = data def push(self, new_data): new_node = Node(data = new_data) new_node . next = self . head new_node. prev = None if self. head is not None: self . head. prev = new_node self.head = new_node def insertAtAfter(self, prev_node, new_data) : if prev _node is None: print( " This node does not exist in the DLL") return new_node = Node (data= new_data) new_node. next = prev_node.next prev_node.next = new_node new_node .prev = prev_node if new_node. next is not None: new_node. next. prev = new_node def append(self, new_data): new_node = Node(data = new_data) last = self. head new_node. next = None if self .head is None: new_ node. prev = None self .head = new_node return while(last. next is not None): last = last. next last. next = new_ node new_node. prev = last def InsertToTail(self, data): if self.start_node is None: new_node = Node(data) self.start_node = new_node return n = self.start_node while n.next is not None: n = n.next new_node = Node(data) n.next = new_node new_node.prev = n def delete_at_end(self): if self.start_node is None: print("The Linked list is empty, no element to delete") return if self.start_node.next is None: self.start_node = None return n = self.start_node while n.next is not None: n = n.next n.prev.next = None def Print(self): if self.start_node is None: print("The list is empty") return else: n = self.start_node while n is not None: print("Element is: ", n.item) n = n.next print("\n") The Function used for insertion: void insertAtTail(ListHead, value): newNode = Node() newNode.value = value newNode.next = NULL while ListHead.next is not NULL then ListHead = ListHead.next newNode.prev = ListHead ListHead.next = newNode insertAfter(ListHead, searchItem, value): List = ListHead NewNode = Node() NewNode.value = value while List.value is not equal searchItem when List = ListHead.next List = List.next NewNode.next = List.next NewNode.prev = List List.next = NewNode With all this in mind, even though inserting elements at the end of a list using .append() or .insert() that will have constant time, O(1), when you try inserting an element closer to or at the beginning of the list, the average time complexity will grow along with the size of the list: O(n). Linked lists, on the other hand, are much more straightforward when it comes to insertion and deletion of elements at the beginning or end of a list, where their time complexity is always constant: O(1). The Sample code: class Node: def __init__(self, data): self.data = data #adding an element to the node self.next = None # Initally this node will not be linked with any other node self.prev = None # It will not be linked in either direction # Creating a doubly linked list class class DoublyLinkedList: def __init__(self): self.head = None # Initally there are no elements in the list self.tail = None def insert_front(self, new_data): # Adding an element before the first element new_node = Node(new_data) # creating a new node with the desired value new_node.next = self.head # newly created node's next pointer will refer to the old head if self.head != None: # Checks whether list is empty or not self.head.prev = new_node # old head's previous pointer will refer to newly created node self.head = new_node # new node becomes the new head new_node.prev = None else: # If the list is empty, make new node both head and tail self.head = new_node self.tail = new_node new_node.prev = None # There's only one element so both pointers refer to null def push_back(self, new_data): # Adding an element after the last element new_node = Node(new_data) new_node.prev = self.tail if self.tail == None: # checks whether the list is empty, if so make both head and tail as new node self.head = new_node self.tail = new_node new_node.next = None # the first element's previous pointer has to refer to null else: # If list is not empty, change pointers accordingly self.tail.next = new_node new_node.next = None self.tail = new_node # Make new node the new tail def peek_front(self): # returns first element if self.head == None: # checks whether list is empty or not print("List is empty") else: return self.head.data def peek_back(self): # returns last element if self.tail == None: # checks whether list is empty or not print("List is empty") else: return self.tail.data def pop_front(self): # removes and returns the first element if self.head == None: print("List is empty") else: temp = self.head temp.next.prev = None # remove previous pointer referring to old head self.head = temp.next # make second element the new head temp.next = None # remove next pointer referring to new head return temp.data def pop_back(self): # removes and returns the last element if self.tail == None: print("List is empty") else: temp = self.tail temp.prev.next = None # removes next pointer referring to old tail self.tail = temp.prev # make second to last element the new tail temp.prev = None # remove previous pointer referring to new tail return temp.data def insert_after(self, temp_node, new_data): # Inserting a new node after a given node if temp_node == None: print("Given node is empty") if temp_node != None: new_node = Node(new_data) new_node.next = temp_node.next temp_node.next = new_node new_node.prev = temp_node if new_node.next != None: new_node.next.prev = new_node if temp_node == self.tail: # checks whether new node is being added to the last element self.tail = new_node # makes new node the new tail def insert_before(self, temp_node, new_data): # Inserting a new node before a given node if temp_node == None: print("Given node is empty") if temp_node != None: new_node.prev = temp_node.prev temp_node.prev = new_node new_node.next = temp_node if new_node.prev != None: new_node.prev.next = new_node if temp_node == self.head: # checks whether new node is being added before the first element self.head = new_node # makes new node the new head printing of the sample output: Output Created DLL is: Traversal in forward direction 1 7 8 6 4 Traversal in reverse direction 4 6 8 7 1 Time Complexity: O(n)Auxiliary Space: O(1)Thus the given section is clearly explained in this section.