problem with Delete nodes From Doubly linked List

[max v max2]

i Had wrote a program that deletes a node from a Doubly liked list.
it dose not work. please help

 #include<iostream>
using namespace std;
struct node{
	int data;
	node *next;
	node *prev;
};

class dl{
public:
	dl();
	void addnode(int x);
	void delnode(int x);
	bool search(int x);
	void traverse();
	int total();

private:
	node* head;
	node *tail;


};


int dl::total()
{
	int c=0;
	if(head==NULL)
		return 0;
	else
	{
		for(node *cur=head;cur!=NULL;cur=cur->next)
			c++;
	}
	return c;
}

void dl::traverse()
{
	for(node *cur=head;cur!=NULL;cur=cur->next)
		cout<<cur->data<<" ";

	
}

bool dl::search(int x)
{
	node *cur=head;
	bool found=false;
	while(cur!=NULL&&!found)
		{if(cur->data==x)
		found=true;
		else
			cur=cur->next;
	}
	return found;
}
	
void dl::delnode(int x)
{
	if(head==NULL)
	{
		cout<<"Empty Doubly Linked List"<<endl;
		return;
	}
	else
	{
	if(search(x))
	{
		node *ptr=head,*cur=head;
		for(cur=head;cur->data!=x;cur=cur->next)
			ptr=ptr->next;
		
		cur=ptr;
		cur->next=ptr->next;
		cur->prev=ptr->prev;
		delete ptr;
		

		
	}
			
	
	else{
		cout<<"the element is not  exist"<<endl;
		return ;
	}
}
}

 void dl::addnode(int x)
{
	node *ptr;
	ptr=new node;
	ptr->data=x;
	ptr->prev=NULL;
	ptr->next=head;
	if(head==NULL)
		tail=ptr;
	else
		(head)->prev=ptr;
		head=ptr;


 }

dl ::dl()
{
	head=tail=NULL;
}
int main()
{
	dl y;
	int z;
	int x;
	do{
		system("cls");
		
		cout<<"1. Insert a node\n"
			<<"2. Delete a particular node\n"
			<<"3. Search for a particular item\n"
			<<"4. Traverse the list in reverse order\n"
			<<"5. Find the total nodes of the list\n"
			<<"6. Exit\n"
			<<"please enter your choice :";
		cin>>x;
		cout<<endl;
		switch(x)
		{
		case 1:{
			
			cout<<"please enter an element to insert :";
			cin>>z;
			y.addnode(z);}break;
		case 2:{
			cout<<"please enter an element to delete :";
			cin>>z;
			y.delnode(z);
			   }break;
		case 3:
			{
				cout<<"please enter a element to search : ";
				cin>>z;
				if(y.search(z))
					cout<<"the element is in the Doubly linked list"<<endl;
				else
					cout<<"the element is not exist"<<endl;
			}break;
		case 4:
			{
				y.traverse();
			}break;
		case 5:{
			cout<<"The number of nodes is "<<y.total()<<endl;
			   }break;
		case 6:{
			cout<<"bye bye"<<endl;
		}break;
		
			}
		cout<<endl;
		system("pause");
	}while(x!=6);
	return 0;
}



		
			



	

[JockX]

There are some optimisations you should consider:

// If you perform a search, you expect to get the results back!
node*  dl::search(int x)
{
    // Traverses list and compares data to x. 
    // returns pointer to node with matching data, 
    // or NULL pointer if search failed
}

void  dl::delnode(int x)
{
    // ...
    // Do not reimplement search inside delete!
    node* toBeDeleted = this.search(x);
    
    if (toBeDeleted != NULL )
    {
        // Unplug toBeDeleted from the chain and kill it.
        
        // Update neighbouring nodes contents, and not just 
        // pointers to neighbouring nodes alone
        toBeDeleted->prev->next = toBeDeleted->next;
        toBeDeleted->next->prev = toBeDeleted->prev;
        
        // What you did (lines 76-77):
        // toBeDeleted->prev = toBeDeleted->next;
        // toBeDeleted->next = toBeDeleted->prev;

        delete toBeDeleted;
    }
}

You should also consider what delete should accept as an argument - it probably should not be an int (node data), because many nodes could have the same data stored. It should accept actual pointer to the node that needs deleting:

// Declared like this
void delnode(node* toBeDeleted) {/* ... */ };

// Called like this:
delnode( search(x) );