CareerCup

say ptr1 points to start of linked list,

if(ptr1==null) return false;

node * ptr2;
ptr2=ptr1->next;
if(ptr1->data==number){
ptr1=ptr2;
return true;
}

while(ptr2){
if(ptr2->data==number){
ptr1->next=ptr2->next;
return true;
}
ptr1=ptr2;
ptr2=ptr2->next;
}
return false;

node* deleteNode (node* head, int val ) {
    node *ptr1, *ptr2 ;
    if ( head == NULL )
      return head ;
    else if ( head->data == val ) {
      head = head->next ;
      return head ;
    }
    ptr1 = head ;
    ptr2 = head->next ;
    while ( ptr2 ) {
      if ( ptr2->data == val ) {
        ptr1->next = ptr2->next ;
        return head ;
      }
      ptr1 = ptr2 ;
    }
    return head ;
  }

node* deleteNode (node* head, int val ) {
    node *ptr1, *ptr2 ;
    if ( head == NULL )
      return head ;
    else if ( head->data == val ) {
      head = head->next ;
      return head ;
    }
    ptr1 = head ;
    ptr2 = head->next ;
    while ( ptr2 ) {
      if ( ptr2->data == val ) {
        ptr1->next = ptr2->next ;
        return head ;
      }
      ptr1 = ptr2 ;
    }
    return head ;
  }

struct SLNode {
    SLNode *next;
    int data;
};
void SL_delete_node(SLNode *head, int value)
{   
    SLNode *prev = NULL;
    
    while (head){
        if (head->data) { // found
            if (NULL == prev) { // this is the only node
                printf("The value is in head of SLL\n");
                return;            
            }
            else { // we have a previous node
                prev->next = head->next;
                //Delete the current node
                delete head;
                break;
            }
        }
        prev = head;
        head = head->next;
    }

}

// Function returns pointer to first node of updated list 
Node* RemoveNode(Node* pFirstNode, int nValue){	
	if(nullptr == pFirstNode){
		return pFirstNode;	
	}

	if(pFirstNode->i == nValue){
		Node* pReturn = pFirstNode->next;
		free(pFirstNode);
		return pReturn;
	}
	
	Node *pCurrent = pFirstNode;
	while((nullptr != pCurrent) && (nullptr != pCurrent->next)){		
		if(pCurrent->next->i == nValue){
			Node* pTemp = pCurrent->next;
			pCurrent->next = pCurrent->next->next;
			free(pTemp);
		}
		pCurrent = pCurrent->next;
	}

	return pFirstNode;
}

/* Returns pointer to the deleted node.
 * Adjust head if needed.
 */
node*
del_node(node **head, int number) {
  node* c, p; #current and previous node
  for (c = *head, p = NULL; c != NULL; c = c->next, p = c)
    if (c->data == number)
      if (p != NULL)
        p->next = c->next;
      else
        *head = c->next;
      break;
  return c;
}

searcAndDelete(char* input)
{
LinkedList *temp;
LinkedList *cur = list;

while (cur)
{
if (cur -> data == input)
{
cur = temp;
temp = temp -> next;
cur -> next = temp -> next;
delete temp;
return;
}
temp = cur;
cur = cur -> next;

}
cout << " Item is not in the list" << endl;
}

void List::mQuestion2(int aValue)
{
	class Node *lTemp = mHead;

	if(lTemp == NULL)
		return;

	if(lTemp->mData == aValue)
	{
		mHead = lTemp->mNext;
		lTemp->mNext = NULL;
		//delete lTemp
		mNoOfElements--;
	}
	else
	{
		while(lTemp->mNext !=NULL && lTemp->mNext->mData != aValue)
		{
			lTemp = lTemp->mNext;
		}

		if(lTemp->mNext == NULL)
		{
			cout << "Element not found" <<endl;
			return;
		}
		
		class Node *lTemp2 = lTemp->mNext;
		lTemp->mNext = lTemp->mNext->mNext;
		lTemp2->mNext = NULL;
		//delete lTemp2;
		mNoOfElements--;
	}
}

Cisco gives hike once in 2-3 years.

New-Joinees only get hike after 2-3 years, so take 100% hike at the time of joining .. . otherwise don't cry after joining. :)