Question

can you guys please help me with these questions thank you

9.Given a Double Linked-List that contains the values in order: 1,2,3,4,5; and the following class declarations: class List private: Node* head; public: PrintBackwards (); class Node{ friend class List; private: int value; Node* next; Node* prev; Write the algorithm PrintBackwards that prints the whole list backwards. So your functionshould output: “ 5,4,3,2,1" Extra Credit if you instead implement the algorithm for a single linked-list (i.e. only using the Node* next pointer). You may change the function declaration if necessary. b. What is the Big-Oh runtime of the function you created? 10. Using the Double Linked-List from Question 9, and given the Algorithm header below: Algorithm RemoveNodeAtValue( value) input integer value to be removed output none Write the C++ implementation of this Algorithm b. What's the Big-Oh runtime of your Algorithm?

Answer 1

a) here is the code to prints whole list backwards

code C++

#include<iostream>
#include<stack>
using namespace std;

class Node
{
friend class List;
private:
int value;
Node *next;
Node *prev;
};
class List{
private:
Node *head;
public:
void printBackwards();
void addNode(int);
void removeNodeAtValue(int);
};
//remove node at value
void List::removeNodeAtValue(int value)
{
Node *ptr=head;
if(head==NULL)
return;
if(head->value==value)
{
head=head->next;
return;
}
while(ptr!=NULL)
{
if(ptr->value==value)
{
ptr->prev->next=ptr->next;
  
}
ptr=ptr->next;
}
}
//print backwards using only singly link list
void List::printBackwards()
{
Node *ptr=head;
stack<int> elements;
while(ptr!=NULL)
{
elements.push(ptr->value);
ptr=ptr->next;
}
while(!elements.empty())
{
cout<<elements.top()<<", ";
elements.pop();
}
cout<<endl;
}
//add node to create link list
void List::addNode(int value)
{
Node *ptr=head;
if(head==NULL)
{
head=new Node();
head->value=value;
head->next=NULL;
head->prev=NULL;
return;
}
Node * temp=new Node();
temp->value=value;
temp->next=NULL;
while(ptr->next!=NULL)
{
ptr=ptr->next;
}
ptr->next= temp;
temp->prev=ptr;
}

int main()
{
List *l= new List();
l->addNode(1);
l->addNode(2);
l->addNode(3);
l->addNode(4);
l->addNode(5);
l->printBackwards();
l->removeNodeAtValue(4);
l->printBackwards();
return 0;
}
output

5, 4, 3, 2, 1,
5, 3, 2, 1,

b) extra credit for using singly link list above code is also using singly link list

void List::printBackwards()
{
Node *ptr=head;
stack<int> elements;
while(ptr!=NULL)
{
elements.push(ptr->value);
ptr=ptr->next;
}
while(!elements.empty())
{
cout<<elements.top()<<", ";
elements.pop();
}
cout<<endl;
}

c) Big o running time for this algorithm in O(N) since to store all the elements in a stack we are traversing link list only once.then we are using one more loop to traverse stack and print elements. so total N+N = O(N)

Question 10

A) above code is also implementation of above algorithm , below is only the function

//remove node at value
void List::removeNodeAtValue(int value)
{
Node *ptr=head;
if(head==NULL)
return;
if(head->value==value)
{
head=head->next;
return;
}
while(ptr!=NULL)
{
if(ptr->value==value)
{
ptr->prev->next=ptr->next;
  
}
ptr=ptr->next;
}
}

b) Big o running time for this algorithm is also O(N) since we are only traversing the doubly link list only once which can only take upto N time in worst case