BST problem z usuwaniem elementu

Witam otóż mam problem z usuwaniem. Podczas próby usuwania wyskakują błędy segmentacji pamięci. Z góry dzięki za pomoc.

klasa drzewa:

class BinarySearchTree
{
    private:
        struct tree_node
        {
           tree_node* left;
           tree_node* right;
           int data;
        };
        tree_node* root;
    public:
        BinarySearchTree()
        {
           root = NULL;
        }
        bool isEmpty() const { return root==NULL; }
        void insert(int);
        void remove(int);
		void max();
		void min();
};

funkcja remove z ktróra mam problem:

void BinarySearchTree::remove(int d)
{
    bool found = false;
    if(isEmpty()) return;

    tree_node* curr;
    tree_node* parent;
    curr = root;
    while(curr != NULL)
    {
         if(curr->data == d)
         {
            found = true;
            break;
         }
         else
         {
             parent = curr;
             if(d>curr->data) curr = curr->right;
             else curr = curr->left;
         }
    }
    if(!found) return;

    //pierwsza mozliwosc, wezel z jednym potomkiem
	if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL && curr->right == NULL))
    {
		delete curr;
		return;
    }

	//wezel
	if( curr->left == NULL && curr->right == NULL)
    {
		if(parent->left == curr) parent->left = NULL;
        else parent->right = NULL; 
		delete curr;
		return;
    }

    //wezel z dwoma potomkami
    if (curr->left != NULL && curr->right != NULL)
    {
		tree_node* chkr;
        chkr = curr->right;
        if((chkr->left == NULL) && (chkr->right == NULL))
        {
            curr = chkr;
            delete chkr;
            curr->right = NULL;
        }
        else //prawy potomek posiada potomka
        {
            //jesli prawy potomek w wezle posiada lewego potomka
            //przechodzimy lewa strona w dol zeby odnalezc najmniejszy element

            if((curr->right)->left != NULL)
            {
                tree_node* lcurr;
                tree_node* lcurrp;
                lcurrp = curr->right;
                lcurr = (curr->right)->left;
                while(lcurr->left != NULL)
                {
                   lcurrp = lcurr;
                   lcurr = lcurr->left;
                }
		 		 		 		 curr->data = lcurr->data;
                delete lcurr;
				lcurrp->left = NULL;
			}
			else
			{
				tree_node* tmp;
				tmp = curr->right;
				curr->data = tmp->data;
				curr->right = tmp->right;
				delete tmp;
			}
        }
		return;
    }
}

Zauwaz, że:

    //pierwsza mozliwosc, wezel z jednym potomkiem
        if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL && curr->right == NULL))
    {
                delete curr;
                return;
    }

rodzic curr dalej wskazuje na curr, który został usunięty.