Solution1: Note that this solution is to delete only one largest number when there are multiple (equal) largest numbers in the list.

void LinkedList::deleteLargest()
{
	Node * prev, *cur=head;
	Node * large_prev=0, *large_cur=head;
	If(cur!=0)
	{
		If(cur->next==0)
			head=0;
		else
		{
			while(cur->next!=0)
			{
				prev=cur;
				cur=cur->next;
				if(cur->data>large_cur->data)
				{
					large_cur=cur;
					large_prev=prev;
				}
			}
			If (large_prev!=0)
				large_prev->next=large_cur->next;
			else
				head=large_cur->next;
		}
		delete large_cur;
	}
}
Yes, we can do this with a single traversal of the list.

Solution2: using recursion (Same as above: delete one largest number)

Node * DelLargest(Node* n)
{
	if (!n) return n;
	bool delete=false;
	return DelLargest_Step(n, n->data, delete);
}

Node * DelLargest_Step(Node *n, int max, bool &del)
{
	if (!n) return n;
	n->next = DelLargest_Step(n->next, max > n->data ? max:n->data, del);
	if (del || n->data<max) return n;
	Node * tmp=n->next;
	delete n;
	del = true;
	return tmp;
}

Solution3: Delete all largest numbers if there are multiple copies of largest numbers.

void LinkedList::DelAllLargest()
{
	if (!head) return;
	bool delete=false;
	int max=head>data;
	head=DelAllLargest_Step(head, max);
}

Node * DelAllLargest_Step(Node *n, int &max)
{
	if (!n) return n;
	if (max<n->data) max=n->data;
	n->next = DelAllLargest_Step(n->next, max);
	if (n->data<max) return n;
	Node * tmp=n->next;
	delete n;
	return tmp;
}

Solution4: use double pointer

void LinkedList:: DelLargest()
{
	Node **n=&head;
	Node **cur=&head;
	while (*cur)
	{
		if ((*cur)->data>(*n)->data) n=cur;
		cur=&((*cur)->next);
	}
	if (*n)
	{
		Node * tmp=*n;
		*n=tmp->next;
		delete tmp;
	}
}