Delete a Node


Problem Statement :


Delete the node at a given position in a linked list and return a reference to the head node. The head is at position 0. The list may be empty after you delete the node. In that case, return a null value.

Example:
list=0->1->2->3
position=2

After removing the node at position 2, list'= 0->1->-3.


Function Description:

Complete the deleteNode function in the editor below.

deleteNode has the following parameters:
- SinglyLinkedListNode pointer llist: a reference to the head node in the list
- int position: the position of the node to remove

Returns
- SinglyLinkedListNode pointer: a reference to the head of the modified list


Input Format:

The first line of input contains an integer n, the number of elements in the linked list.
Each of the next n lines contains an integer, the node data values in order.
The last line contains an integer, position, the position of the node to delete.


Constraints:
     1.  1<=n<=1000
     2.  1<=list[i]<=1000


Solution :



title-img 


                            Solution in C :

In C:

//the following function is all that is needed to complete
// the challenge in hackerrank platform.

SinglyLinkedListNode* deleteNode(SinglyLinkedListNode* llist, int position) {
    if((position) == 0) {
        return llist->next;
    }
    llist->next = deleteNode(llist->next, position-1);
    return llist;
}









In C++:

//the following function is all that is needed to complete
//the challenge in hackerrank platform

Node* Delete(Node *head, int position)
{
  // Complete this method
    Node *prev = NULL;
    Node *ptr = head;
    
    int pos = 0;
    
    if(position==0)
    {
        head=head->next;
        delete (ptr);
    }
    else
    {
        while(position!=pos)
        {
            ++pos;
            prev=ptr;
            ptr=ptr->next;
        }
        
        if(ptr!=NULL)
        {
            prev->next=ptr->next;
            delete (ptr);
        }
    }
    return head;
}









In Java:

//the following method is all that is needed to complete the 
//challenge in hackerrank plartform

static SinglyLinkedListNode deleteNode(SinglyLinkedListNode llist, int position) {
        int currentNodePosition = 0;
        SinglyLinkedListNode head = llist;
        SinglyLinkedListNode currentNode = llist;
        
         if (position == 0) {
            head = head.next;
            return head;
        }
        
        while (currentNodePosition < position - 1) {
            currentNode = currentNode.next;
            currentNodePosition++;
        }
        
        if (currentNode.next != null && currentNode.next.next != null) {
            currentNode.next = currentNode.next.next;
        }
        
        return head;
    }










In Python 3: 

#the following method is all that is needed to complete the
#challenge in hackerrank platfrom

def Delete(head, position):
  currentPos = 0
  prevNode = None
  node = head
  while currentPos < position:
    currentPos = currentPos+1
    prevNode = node
    node = node.next

  if prevNode is not None:
      prevNode.next = node.next
      return head
  else:
      n = node.next
      node.next = None
      return n








View More Similar Problems

Pair Sums

Given an array, we define its value to be the value obtained by following these instructions: Write down all pairs of numbers from this array. Compute the product of each pair. Find the sum of all the products. For example, for a given array, for a given array [7,2 ,-1 ,2 ] Note that ( 7 , 2 ) is listed twice, one for each occurrence of 2. Given an array of integers, find the largest v

View Solution →

Lazy White Falcon

White Falcon just solved the data structure problem below using heavy-light decomposition. Can you help her find a new solution that doesn't require implementing any fancy techniques? There are 2 types of query operations that can be performed on a tree: 1 u x: Assign x as the value of node u. 2 u v: Print the sum of the node values in the unique path from node u to node v. Given a tree wi

View Solution →

Ticket to Ride

Simon received the board game Ticket to Ride as a birthday present. After playing it with his friends, he decides to come up with a strategy for the game. There are n cities on the map and n - 1 road plans. Each road plan consists of the following: Two cities which can be directly connected by a road. The length of the proposed road. The entire road plan is designed in such a way that if o

View Solution →

Heavy Light White Falcon

Our lazy white falcon finally decided to learn heavy-light decomposition. Her teacher gave an assignment for her to practice this new technique. Please help her by solving this problem. You are given a tree with N nodes and each node's value is initially 0. The problem asks you to operate the following two types of queries: "1 u x" assign x to the value of the node . "2 u v" print the maxim

View Solution →

Number Game on a Tree

Andy and Lily love playing games with numbers and trees. Today they have a tree consisting of n nodes and n -1 edges. Each edge i has an integer weight, wi. Before the game starts, Andy chooses an unordered pair of distinct nodes, ( u , v ), and uses all the edge weights present on the unique path from node u to node v to construct a list of numbers. For example, in the diagram below, Andy

View Solution →

Heavy Light 2 White Falcon

White Falcon was amazed by what she can do with heavy-light decomposition on trees. As a resut, she wants to improve her expertise on heavy-light decomposition. Her teacher gave her an another assignment which requires path updates. As always, White Falcon needs your help with the assignment. You are given a tree with N nodes and each node's value Vi is initially 0. Let's denote the path fr

View Solution →