can anyone solve this please

[mick777]

Consider the following implementation of the node and doubly linked-list:

Extend the class doubly_linked_list by adding the following methods:

*Largest method .This method should return the largest element in a doubly linked-list.

*Delete method. This method should delete the first occurrence of an element (value) from a doubly linked-list.

template <class type>
class node
{
public:
	type info;
	node<type> * next;// next
	node<type> * prev;//back

};

template <class type>
class doubly_linked_list
{
	//data members
private:
	node<type> *head, *tail;
	int length;
public:
	doubly_linked_list()
	{
		head = tail = NULL;
		length = 0;
	}
	bool isEmpty()
	{   // return (head==NULL);
		if (head == NULL)
			return true;
		else
			return false;
	}

	void Append(type e)
	{
		node<type> *newnode = new node<type>;
		newnode->info = e;
		if (isEmpty())
		{
			newnode->next = NULL;
			newnode->prev = NULL;
			head = newnode;
			tail = newnode;
		}
		else
		{
			tail->next = newnode;
			newnode->prev = tail;
			newnode->next = NULL;
			tail = newnode;
		}
		++length;

	}

	void Display()
	{
		if (isEmpty()) { cout << "The linked list is empty !!!!"; return; }
		cout << "list elements: ";
		node<type> * current = head;
		while (current != NULL)
		{
			cout << current->info << " ";
			current = current->next;
		}
		cout << endl;

	}

	void ReverseDisplay()
	{
		if (isEmpty()) { cout << "The linked list is empty !!!!"; return; }
		cout << "Reverse list elements: ";
		node<type> * current = tail;
		while (current != NULL)
		{
			cout<< current->info<<" ";
			current = current->prev;
		}
		cout << endl;
	}

	void insert(type e, int index)
	{
		if (index< 1 || index>length + 1)
		{
			cout << "Invalid index !!!!"; return;
		}
		else
		{
			node<type> * newnode = new node <type>;
			newnode->info = e;
			if (index == 1)
			{
				newnode->prev = NULL;
				if (isEmpty())
				{
					newnode->next = NULL;
					head = tail = newnode;
				}
				else {
					newnode->next = head;
					head->prev = newnode;
					head = newnode;
				}



			}
			else
			{
				node<type> * current = head;
				int i = 1;
				while (i != index - 1)
				{
					current = current->next;
					++i;
				}

				if(current !=tail)
				{ 
				current->next->prev = newnode;
				newnode->next = current->next;
				current->next = newnode;
				newnode->prev = current;
				}
				else
				{
					current->next = newnode;
					newnode->prev = current;
					newnode->next = NULL;
					tail = newnode;
				}

			}





		}
	}

};

[TheIdeasMan]

We shouldn't do your homework.

[againtry]

@OP
DLLists can be walked through in both directions head->tail, tail->head.

You get the maximum by 'walking through the list.
Select a suitable current_maximum value.
Go to the next node and if the value there is greater than that then replace the current_maximum.
Keep going through that to the end and the current-maximum is the value you want.


You delete a value by walking through the list, finding the relevant value. The first will be the one found by going head->tail.
When/if its found you have to disconnect it from the list taking into account whether the value is internal to the list or at the ends.

There are reams of tutorials on this eg https://www.geeksforgeeks.org/doubly-linked-list/

[seeplus]

Where did the code for the original class come from? It's not good modern C++ code and can be improved!

[mick777]

her is the required functions for the above code:
but i cant have output



int getMaxNode(node *head){

/* Input Validation */

if(head == NULL){

printf("Error : Invalid Input !!!!\n");

return INT_MIN;

}

int max = head->data;

while(head != NULL){

if(head->data > max){

max = head->data;

}

head = head->next;

}

return max;

}

/* Function to delete a node in a Doubly Linked List.

head_ref --> pointer to head node pointer.

del --> pointer to node to be deleted. */

void deleteNode(node** head_ref, node* del)

{

/* base case */

if (*head_ref == NULL || del == NULL)

return;

/* If node to be deleted is head node */

if (*head_ref == del)

*head_ref = del->next;

/* Change next only if node to be deleted

is NOT the last node */

if (del->next != NULL)

del->next->prev = del->prev;

/* Change prev only if node to be deleted

is NOT the first node */

if (del->prev != NULL)

del->prev->next = del->next;

/* Finally, free the memory occupied by del*/

free(del);

}

/* function to delete all occurrences of the given

key 'x' */

void deleteFirstOccurOfX(struct Node** head_ref, int x)

{

/* if list is empty */

if ((*head_ref) == NULL)

return;

node* current = *head_ref;

node* next;

/* traverse the list up to the end */

while (current != NULL) {

/* if node found with the value 'x' */

if (current->data == x) {

/* save current's next node in the

pointer 'next' */

next = current->next;

/* delete the node pointed to by

'current' */

deleteNode(head_ref, current);

break;

}

/* else simply move to the next node */

else

current = current->next;

}

}

[seeplus]

Please format code before posting, and use code tags as per your first post!