Create an Ordered Doubly Linked List in C++. Remember that an ordered Linked List is one where inserts automatically place a new node so that all the nodes retain a certain order. This list should be templated where items should be in "ascending" order (i.e., if it is a list of numbers, it should be of order of least to greatest).

ALGORITHM : Insert(data):1. Create a new node with the given data.2. Check if the list is empty. a. If the list is empty, change the head pointer to point to the new node. b. If the list is not empty, insert the node at the correct position. i. If the data of the new node is less than or equal to the data of the head node, insert the new node before the head node. ii. If the data of the new node is greater than the data of the head node, insert the new node after the head node.Remove(data):1. Check if the list is empty. a. If the list is empty, return.2. Check if the data to be deleted is present in the head node. a. If the data is present in the head node, delete the head node.3. Check if the data to be deleted is present in the tail node. a. If the data is present in the tail node, delete the tail node.4. Check if the data to be deleted is present in the nodes between the head and tail nodes. a. If the data is present in the nodes between the head and tail nodes, find the node and delete it.PrintList():1. Check if the list is empty. a. If the list is empty, print “List is empty” and return.2. Print the data of each node starting from the head node.Source code : #include <iostream>using namespace std; template <class T> class OrderedDoublyLinkedList{ private: class Node { public: T data; Node* next; Node* prev; }; Node* head; Node* tail; int size; public: OrderedDoublyLinkedList(); void insert(T data); void remove(T data); bool isEmpty(); void printList();}; template <class T>OrderedDoublyLinkedList<T>::OrderedDoublyLinkedList(){ head = NULL; tail = NULL; size = 0;} template <class T>void OrderedDoublyLinkedList<T>::insert(T data){ Node* newNode = new Node(); newNode->data = data; newNode->next = NULL; newNode->prev = NULL; if (head == NULL) { head = newNode; tail = newNode; } else { if (data <= head->data) { newNode->next = head; head->prev = newNode; head = newNode; } else if (data >= tail->data) { newNode->prev = tail; tail->next = newNode; tail = newNode; } else { Node* current = head; while (current->data < data) { current = current->next; } newNode->prev = current->prev; newNode->next = current; current->prev->next = newNode; current->prev = newNode; } } size++;} template <class T>void OrderedDoublyLinkedList<T>::remove(T data){ if (head == NULL) return; if (head->data == data) { if (head->next == NULL) { delete head; head = NULL; tail = NULL; } else { head->next->prev = NULL; head = head->next; } size--; return; } if (tail->data == data) { tail->prev->next = NULL; tail = tail->prev; size--; return; } Node* current = head; while (current->data != data) { current = current->next; if (current == NULL) return; } current->prev->next = current->next; current->next->prev = current->prev; delete current; size--;} template <class T>bool OrderedDoublyLinkedList<T>::isEmpty(){ return (size == 0);} template <class T>void OrderedDoublyLinkedList<T>::printList(){ if (head == NULL) { cout << "List is empty" << endl; return; } Node* current = head; cout << "List: "; while (current->next != NULL) { cout << current->data << ", "; current = current->next; } cout << current->data << endl;} int main(){ OrderedDoublyLinkedList<int> list; list.insert(1); list.insert(4); list.insert(3); list.insert(2); list.insert(5); list.insert(7); list.insert(6); list.insert(8); list.insert(12); list.insert(9); list.printList(); list.remove(2); list.printList(); list.remove(9); list.printList(); list.insert(14); list.remove(7); list.printList(); list.remove(1); list.printList();}Code screenshot :Output : Explanation : The code defines a class OrderedDoublyLinkedList that can store data of any type (specified by the template parameter T). The class has a private inner class Node that represents a node in the linked list. Each node has data, a pointer to the next node, and a pointer to the previous node. The OrderedDoublyLinkedList class has a head pointer, a tail pointer, and a size variable. The head pointer points to the first node in the list, the tail pointer points to the last node in the list, and the size variable stores the number of nodes in the list. The class has member functions for inserting and removing data, checking if the list is empty, and printing the list. The insert() function inserts data into the list in sorted order. If the list is empty, the new node becomes the head and tail of the list. If the data is less than or equal to the data in the head node, the new node is inserted before the head node. If the data is greater than or equal to the data in the tail node, the new node is inserted after the tail node. Otherwise, the new node is inserted after the node that has data greater than the

Related questions