Same here...

when head is NULL you need to make newNode->next = NULL, else the linked list wouldn't end with a NULL.

Small modification below.

if (head == NULL) {
    newNode->next = NULL;
    return newNode;
  }

this solution will fail for 1st position.

Here, if you write the below code, its not going inside it, what's the reason: if(head == NULL) cout<<"Head is NULL"<

newNode->next = currentNode->next; currentNode->next = newNode;

please explain

please explain currentNode->next=newNode;

You aren't freeing the dynamically allocated newNode and also head when position is 0.

Added belts and braces

Node* InsertNth(Node *head, int data, int position) { Node newNode = (Node)malloc(sizeof(Node)); newNode->data = data;

if (head == NULL) {
    return newNode;
}

if (position == 0) {
   newNode->next = head;
   return newNode;
}

Node *currentNode = head;

    while(currentNode->next != NuLL && position - 1 > 0) {
    currentNode = currentNode->next;
    position--;
}

    if(currentNode ->next == NULL)
    {
        cout << "No element at position "<< position << endl;
        return;
    }

newNode->next = currentNode->next;
currentNode->next = newNode;

return head;

}

In c++

SinglyLinkedListNode* insertNodeAtPosition(SinglyLinkedListNode* head, int data, int position) {
SinglyLinkedListNode *temp=new SinglyLinkedListNode(data);
SinglyLinkedListNode *nh= head;
for(int i=0;i<position-1;i++)
{
    nh=nh->next;
}
SinglyLinkedListNode *t;
t=nh->next ;
nh->next=temp;
temp->next=t;
return head;
}

Here is a different solution in Java. Took me awhile to figure out the different test secarnios. We should keep track of the element before the given position so that we can modify the next element.

Node InsertNth(Node head, int data, int position) {
    Node newNode = new Node();
    Node header = head;

    // scenario when head is null
    if ( head == null) {
        newNode.data = data;
        return newNode;
    }

    newNode.data = data;
    // scenario when we want to insert in the first element on the list
    if (position == 0) {
        newNode.next = head;
        header = newNode;
        return header;
    }

    // insert somewhere else 1th, 2th, 3th, etc...
    // should stop the element before the position to keep track of next element and assign to a new element

    for (int i=1; i < position && head.next !=null; i++) {
        head = head.next;
    }
    if (head.next != null) {
        newNode.next =  head.next;
        head.next = newNode;
    } else {
        head.next = newNode;
    }
    return header;
}

what does the "newNode.next = cur.next;" line do?

When the input's head is empty and position > 0, I think you will have a problem at "cur = cur.next" inside the while.

You are correct. I think they're only printing non-duplicate values.

Thanks man :)

The problem here is you add a new node to the linked list but never update the head or the tail when needed. For example when the passed head is null (empty list). You just return the newNode. The head supposes to reference to the newNode but you never do it here. You cannot do it because you do not have access to the head here. If you inserted at the last position of a not empty linked list, then you would update the tail as well but you cannot do it. You do not have access to the tail.

Why so long?

Node** p = &head;
for(int i = 0; i < position; ++i)
    p = &(*p)->next;
*p = new Node {data, *p};
return head;

Agreed in fact something like what you are sayign is the most elegant solution, I thought mine was :/

Node n = new Node();
n.data = data;
Node cur = head;
Node prev = null;
int i = 0;
while (i < position) {
   prev = cur;
   cur = cur.next; 
   i++;
   // will crash if input head = null and pos > 0 
   // we assume no such inputs
}
n.next = cur;
if (prev != null) {
	prev.next = n;
    return head;
}
return n;

Head needs to be updated and point where the next node is pointing.The whole idea behind using recursion is to make the problem smaller and reaching the base case.To make the problem smaller we will shift head by 1 each time and check for base case.We will do it till we reach base case execute that and return.

Both are wrong IMHO. 'position' variable could take value 0 according to the constraints of the problem. That means that you have to insert the data in the head of the list. But in your code you are inserting in position 1 when the 'position' value is 0. Your code behaves the same when 'position' is 1 and when 'position' is 0.

I will try my best.

def insertNodeAtPosition(head, data, position):
n = head #set variable n to equal head
for _ in range(position - 1): 
    n = n.next #loop thru llist until you get to desired position
n_next = n.next #set variable n_next to equal the next node
n.next = SinglyLinkedListNode(data) #set the next position as the new number
n.next.next = n_next #and the one after that as what used to be n.next
return head

Thanks for pointing out. I didn't get that idea. 😅

May be test cases are changed, following code passes all test cases:

def InsertNth(head, data, position):
    if position == 0:
        head = Node(data, head)
    else:
        cur = head
        for _ in range(position-1):
            cur = cur.next

        cur.next = Node(data, cur.next)

    return head

Without the need to check for the 0th position case:

def insertNodeAtPosition(head, data, position):
        # Null case
        if head is None:
                return SinglyLinkedListNode(data)

        cur = head

        for _ in range(position - 1):
                cur = cur.next

        cur.next, cur.next.next = SinglyLinkedListNode(data), cur.next

        return head