1. Within function empty(), write the Boolean expression to determine if the list is empty. Do not put spaces in your answer. That is, X=-Y is okay, but X == Y is not. 2. True or False: Removing the last element from the list conditionally requires setting sentinel._next to nullptr. 3. Implement push_front(data) in 5 lines of code. Do not separate identifiers and operators with spaces, but do separate identifiers with a single space. That is, X=Y and new Data are okay, but X = Y, newData , and new Data are not. Don't forget your semicolon. template void DuublyLinkeList:: push_front( const 1 & data) { // 1. Get and initialize a new dynamically created Node called newNode // 2. Set the new node's next pointer to point to the first node in the list // 3. Set the new node's previous pointer to the list's dummy node // 4. Set the first node's previous pointer to point to the new node // 5. Set the dummy node's next pointer to point to the new node } ******** ****** ** Class DoublyLinkedList - a very basic example implementation of the Doubly Linked List Abstract Data Type ** This file provides a one-dummy node, circular implementation of the DoublyLinkedList interface ** Empty (size = 0): V V I prev | not used | next ** sentinel A A A begin( (aka head, sentinel.next) tail (aka sentinel.prev) end size = 3: -+ 1 +- ------ I - prev | not used | next |----> prev | data | next |----> prev data | next prev | data | next |---- -- | sentinel A A A A 1 1 1. 1. end() tail (aka sentinel.prev) begin() (aka head, sentinel.next) **** */ #pragma once #include size_t #include length_error, invalid argument #include "DoublyLinkedlist.hpp" ******** *******/ ***** ******** ********/ /***** ** DoublyLinkedList with one dummy node function definitions namespace CSUF::CPSC131 { /**** ** A doubly linked list's node ************ template struct DoublyLinkedList::Node { Node() = default; Node const Data_t & element ) : _data( element) {} Data_t_data; linked list element value Node * _next = this; next item in the list Node * _prev = this; previous item in the list 11 // ************ *********** ***/ /****** ** A doubly linked list's private data implementation template struct DoublyLinkedList::PrivateMembers A specific implementation's private members (attributes, functions, etc) { Node _sentinel; dummy node. The first node of the list (_head) is at _sentinel->next; Node *& _head = _sentinel._next; An easier to read alias for the list's head, which is a pointer-to-Node Node *& _tail = _sentinel._prev; last element in the list. tail->next always points to _sentinel std::size_t _size = 0; number of elements in the collection }; template typename DoublyLinkedList::Iterator DoublyLinkedList:.insertBefore( const Iterator & position, const Data_t & element ) { Node * newNode = new Node( element ); create and populate a new node newNode->_next = position(); newNode->_prev = position->_prev; position()->_prev->_next = newNode; position() ->_prev = newNode; ++self->_size; return newNode; } template typename DoublyLinkedList::Iterator DoublyLinkedList:.remove( const Iterator & position ) { if( empty ) throw std:: length_error ( "Attempt to remove from an empty list ); if(position == end()) throw std::invalid_argument( "Attempt to remove at an invalid location" ); position()->_next->_prev = position()->_prev; position->prev->next = position ->next; --self->_size; Iterator returnNode( position()->_next ); return the node after the one removed delete position(); delete what used to be the old node return returnNode; } template typename DoublyLinkedList::Iterator DoublyLinkedList::end() const { return &self->_sentinel; } template typename DoublyLinkedList::Iterator DoublyLinkedList::rend() { return &self->_sentinel; } const