CareerCup

Limitation: Cannot delete the last node.

if(node->next == null) return;

node->data = node->next->data;
node->next = node->next->next;
delete node->next;

In above answer, how will you update an arbitrary "previous" element's ->next pointer to your "node->next" value?

Wont work. List gets broken.

Must have a doubly linked list; then its trivial.

node.data = node.next.data
temp = node.next
delete node.next
node.next = temp

while(ptr->link!=NULL)
{
ptr->info=ptr->link->info;
if(ptr->link->link==NULL)
{
free(ptr->link->link);
ptr->link=NULL;
exit(0);
}
ptr=ptr->link;
}
/* In this code i am simply shifting the node info towards left and finally freeing the last node

Idea is very well known and It can be done in Constant time ,Having One limitation(If last node is passed)..Please have the following code snippet..

void delete(struct node *x) 
{
     struct node *y=NULL;
     
     y=x->next;
     x->data=y->data;
     x->next=y->next;
     free(y);
}

If you find any mistake then please let us know.

delete(Node n)
{
if(n.next == null)
{
n=null;
return;
}
n.data = n.next.data;
delete(n.next);
}

I'm surprised that none of you have mentioned how you'll move forward as well as backward of any arbitrarily given node!!
To me the catch is to assume that the list be either a doubly linked list or a circular list so that given any arbitrary node, you can traverse through all nodes.
Once any one of these assumptions is considered, rest of the solution is trivial.

void Adrs_of_node_to_be_deleted(NODE *node)
{
if(node->next == NULL)
{
printf("You are trying to delete last Node which is not possible as you should know previous node adrs to make it point to null after deleting last node..\n");
return;
}

while(node->next != NULL)
{
node->data = node->next->data;
if(node->next->next==NULL)
{
free(node->next);
node->next = NULL;
return;
}
node->next = node->next->next;
node = node->next;
}

return;
}

If this linked list is a doubly linked list. Then, we can do this.

x->next->prev = x->prev;
x->prev->next = x->next;

delete x;

If singly linked list. just copy the next node value to current node, and repeat till end, and delete the last node.

Its really simple:
what you have to do is:
1) take the next node's value in this node.
2) delete the next node.

if the given node is the last node then handle separately.
code using java.

public void delNode(Node curr)
{
	if(curr.next==null)
	{
		curr=null; // in case curr is last
		return;
	}

	curr.info=curr.next.info;
	curr.next=curr.next.next;
}