Please help with this. Read the files carefully. Points one

and two have been marked in the definition of OLList::insert and point three in function OLList::remove.

Draw memory diagram when program reached these points for the first time.

Submit your diagrams. Please provide a digital copy of your diagram using a scanner and post it as part of your lab

report on the D$2$L$.$ Also make sure the scanned copy of your diagram is clear and readable.

Ex E:

$//$ lab$4$ExE.cpp

$//$

$//$ ENSF $337$ Spring $2024$ Lab $4$ Exercise E

$//$

#include

using namespace std;

#include "OLList.h$"$

int main$()$

$\{$

OLList the$\_$list;

cout $<<$ "List just after creation: $"$;

the$\_$list.print$()$;

the$\_$list.insert$(330)$;

the$\_$list.insert$(440)$;

the$\_$list.insert$(220)$;

the$\_$list.insert$(110)$;

cout $<<$ "List after some insertions: $"$;

the$\_$list.print$()$;

the$\_$list.remove$(550)$;

the$\_$list.remove$(330)$;

cout $<<$ "List after some removals: $"$;

the$\_$list.print$()$;

return $0$;

$\}$

OLLIST.h:

$//$ OLList.h

$//$ ENSF $337$ Spring $2024$ Lab $4$ Exercises E and F

#ifndef OLLIST$\_$H

#define OLLIST$\_$H

typedef int ListItem;

struct Node $\{$

ListItem item;

Node $*$next;

$\}$;

class OLList $\{$

public:

OLList$()$; $//$ PROMISES: Creates empty list.

OLList$($const OLList& source$)$;

OLList& operator $=($const OLList& rhs$)$;

~OLList$()$;

void insert$($const ListItem& itemA$)$;

$//$ PROMISES:

$//$ A node with a copy of itemA is added in

$//$ a way that preserves the nondecreasing

$//$ order of items in nodes.

void remove$($const ListItem& itemA$)$;

$//$ PROMISES:

$//$ If no node has an item matching itemA,

$//$ list is unchanged.

$//$ Otherwise exactly one node with

$//$ its item $==$ itemA is removed.

void print$()$ const;

$//$ PROMISES:

$//$ Prints items in list on a single line, with commas separating

$//$ the items and square brackets marking the ends of the list.

$//$ NOTE:

$//$ This is different from the print function presented in lectures.

private:

Node $*$headM;

void destroy$()$;

$//$ Deallocate all nodes, set headM to zero.

void copy$($const OLList& source$)$;

$//$ List becomes copy of source.

$\}$;

#endif

OLLIST.cpp:

$//$ OLList.cpp

$//$ ENSF $337$ Spring $2024$ Lab $4$ Exercise E and F

#include

#include

using namespace std;

#include "OLList.h$"$

OLList::OLList$()$

: headM$($nullptr$)$

$\{$

$\}$

OLList::OLList$($const OLList& source$)$

$\{$

copy$($source$)$;

$\}$

OLList& OLList::operator $=($const OLList& rhs$)$

$\{$

if $($this $!=$ &rhs$)\{$

destroy$()$;

copy$($rhs$)$;

$\}$

return $*$this;

$\}$

OLList::~OLList$()$

$\{$

destroy$()$;

$\}$

void OLList::print$()$ const

$\{$

cout $<<\text{'}[\text{'}$;

if $($headM $!=$ nullptr$)\{$

cout $<<\text{'}\text{'}<<$ headM$->$item;

for $($const Node $*$p $=$ headM$->$next; p $!=$ nullptr; p $=$ p$->$next$)$

cout $<<","<<$ p$->$item;

$\}$

cout $<<"]$

$"$;

$\}$

void OLList::insert$($const ListItem& itemA$)$

$\{$

Node $*$new$\_$node $=$ new Node;

new$\_$node$->$item $=$ itemA;

if $($headM $==$ nullptr $||$ itemA $<=$ headM$->$item $)\{$

new$\_$node$->$next $=$ headM;

headM $=$ new$\_$node;

$//$ point one

$\}$

else $\{$

Node $*$before $=$ headM; $//$ will point to node in front of new node

Node $*$after $=$ headM$->$next; $//$ will be nullptr$/0$ or point to node after new node

while$($after $!=$ nullptr && itemA $>$ after$->$item$)\{$

before $=$ after;

after $=$ after$->$next;

$\}$

new$\_$node$->$next $=$ after;

before$->$next $=$ new$\_$node;

$//$ point two

$\}$

$\}$

void OLList::remove$($const ListItem& itemA$)$

$\{$

$//$ if list is empty, do nothing

if $($headM $==$ nullptr $||$ itemA $<$ headM$->$item$)$

return;

Node $*$doomed$\_$node $=$ nullptr;

if $($itemA $==$ headM$->$item$)\{$

doomed$\_$node $=$ headM;

headM $=$ headM$->$next;

$\}$

else $\{$

Node $*$before $=$ headM;

Node $*$maybe$\_$doomed $=$ headM$->$next;

while$($maybe$\_$doomed $!=$ nullptr && itemA $>$ maybe$\_$doomed$->$item$)\{$

before $=$ maybe$\_$doomed;

maybe$\_$doomed $=$ maybe$\_$doomed$->$next;

$\}$

$//$ point three

$\}$

$//$ the remaining part of this function is missing. As part of exercise A

$//$ students are supposed to complete the rest of the definition of this function.

$\}$

void OLList::destroy$()$

$\{$

$//$ this function is not properly designed. As part of the exercise A

$//$ students are supposed to remove the folloiwng lines and

$//$ complete the definition of this helper function.

cout $<<$ "OLList::destroy was called but isn't ready for use"

$<<"--$program is terminated.

$"$;

headM $=$ nullptr;

$\}$

void OLList::copy$($const OLList& source$)$

$\{$

$//$ this function is not properly designed. As part of the exercise A

$//$ students are supposed to remove the folloiwng lines and

$//$ complete the definition of this helper function.

$//$ The only effect of the next line is to tell the compiler

$//$ not to generate an "unused argument" warning. Don't leave it

$//$ it in y