CareerCup

void delete(Node*& n, int elem) {
  if (!n) return;
  Node* curr = n;
  Node* prev = NULL;
  while (curr != NULL) {
    Node* curr_next = curr->next;
    if (curr->val == elem) {
      delete curr;      
      if (prev) prev->next = curr_next;
      else n = curr_next; 
    }
    else prev = curr;
    curr = curr_next;
  }
}

this is simple algo ,traverse the list ,delete the node whenever value matches.
start node is special case which is handled saperatly .

void delete(int x,node *start)
{
node *current=start;
while(current)
{
if(current->value==x)  //if we have to delete start node
{
if(current==start)
{
node *temp=start;
current=current->next;
start=current;
delete(node);
}
else
{
node *temp=current->next;
current->value=current->next->value;
current->next=current->next->next;
current=current->next;
delete(temp);
}
}
}

public static LinkedListNode delete_given_number(LinkedListNode head,int givenNumber){
if(head==null){
return null;
}
while(head.data==givenNumber){
head=head.next;
if(head==null){
return null;
}
}
LinkedListNode pervious=head;
LinkedListNode current=head;
while(current!=null){
if(current.data==givenNumber){
pervious.next=current.next;
}
else{
pervious=current;
}
current=current.next;
}

return head;
}

Full working code : awesomecoder.blogspot.com/2012/08/delete-all-matching-elements-in-linked.html

Node* deleteNode(Node* head,int data){
 Node* temp;
 Node* n;
 temp = head;
 while(temp != NULL){
  if(temp->data == data){
   head = temp->next;
   temp->next = NULL;
   free(temp);
   temp = head;
   continue;
  }
  n = temp->next;
  if(n != NULL && n->data == data){
   temp->next = n->next;
   n->next = NULL;
   free(n);
   continue;
  }
  if(n == NULL){
   break;
  } else {
   temp = temp->next;
  }
 }
 return head;
}

Here's a solution which works for Nodes<ValueType>

static <ValueType> Node<?> remove(Node<?> head, final ValueType targetValue) {
        Node<?> start = head;

        //System.out.println("Target value: " + targetValue);

        // handle base cases
        if (head == null) {
            return null;
        } else if ((head != null) && (head.next == null) &&
                targetValue.equals(head.value)) {
            return null;
        } else if ((head != null) && (head.next != null) &&
                (head.next.next == null) && targetValue.equals(head.value)) {
            return start = head.next;
        }

        //System.out.println("Start b4 loop: " + start);
        //System.out.println("Head b4 loop: " + head);

        while (head != null) {
            //printList(start);

            if (targetValue.equals(head.value)) {
                head = head.next;
                start = head;
            } else if (head.next!=null && targetValue.equals(head.next.value)) {
                head.next = head.next.next;
            } else {
                head = head.next;
            }

            //System.out.println("Start post loop: " + start);
            //System.out.println("Head post loop: " + head);
        }

        return start;
    }

Test output:
Original list: 3 1 2 3 3 5 3 
Modified list: 1 2 5

struct LinkedList* deleteDuplicate(struct LinkedList *head, int data)
{
	struct LinkedList *flag , *temp=head;
	int i;
       //delete duplicate data  if start from first node
	while( (head) && (head)->data == data)  
	{
		temp = head;
		head = temp->next;
		if(temp)
		{
			temp->next = NULL;
			free(temp);
		}	
	}

// delete node if repeated data after the start node
	while(temp)
	{
		flag = temp;
		temp = temp->next;	
		if(temp  && temp->data == data)
		{
			flag->next = temp->next;
			temp->next = NULL;
			free(temp);
			temp = flag;
		}
	}
return head;
}

prev=head;
cur=head->link;
while(cur!=NULL)
{
if(value==cur->data)
{
temp=cur;
cur=cur->link;
prev->link=cur;
free(temp);
}
else
{
prev=prev->link;
cur=cur->link;
}
}

Java version:

public void delete(int value){
		Node current = this.head;
		Node prev = null;
		if(current == null)
			return;
		while(current!=null){
			if(current.getData() == value){
				if(prev == null){
					this.head = current.getNext();
					current.setNext(null);
					current = this.head;
				}else{
					prev.setNext(current.getNext());
					current.setNext(null);
					current = prev.getNext();
				}
			}
			else{
				prev = current;
				current = current.getNext();
			}
		}
	}

public void deleteData(int data)
	{
       if(root == null ) return;
       
       while(root != null && root.getData() == data)
    	   root = root.next;
       
       Node prev = root;
       Node next = root;
       
       while(next != null)
       {
    	   
    	   if(next.getData() == data)
    	   {
    		   prev.next = next.next;
    	   }
    	   else 
    	   {   
    		   prev = next;		
    	   }
    	   
    	   next = next.next;
       }
		
		
	}

void deletecopies(struct listnode *head, int data)
{
	struct listnode *current =head; temp =head;

	while ( current)
	{
		if ( current->data == data)
		{
			if (current == head )
			{
				head = head->next;
				free(current);
				current = head;
			}
			else
			{				
				temp->next = current->next;
				free(current);
				current = temp->next;
			}
			continue;

		}
		temp = current;
		current = current->next;
	}
}

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. :)

One solution is to gave 3 Nodes- slow, current and fast. Iterate over the list :
if(current.data == input value) {
slow.next=fast;
}