## Algorithm

Problem Name: Data Structures - Insert a node at a specific position in a linked list

In this HackerRank in Data Structures - Insert a node at a specific position in a linked list solutions

Given the pointer to the head node of a linked list and an integer to insert at a certain position, create a new node with the given integer as its data

attribute, insert this node at the desired position and return the head node.

A position of 0 indicates head, a position of 1 indicates one node away from the head and so on. The head pointer given may be null meaning that the initial list is empty.

Example

head refers to the first node in the list 1 -> 2 -> 3

data = 4

position = 2

Insert a node at position 2 with data = 4 The new list is 1 -> 2 -> 4 -> 3

Function Description Complete the function insertNodeAtPosition in the editor below. It must return a reference to the head node of your finished list.

insertNodeAtPosition has the following parameters:

• data: an integer value to insert as data in your new node
• position: an integer position to insert the new node, zero based indexing

Returns

• SinglyLinkedListNode pointer: a reference to the head of the revised list

Input Format

The first line contains an integer n the number of elements in the linked list.
Each of the next n lines contains an integer SinglyLinkedListNode[i].data.
The next line contains an integer data the data of the node that is to be inserted.
The last line contains an integer position.

Constraints

• 1 <= n <= 1000
• 1 <= SinglyLinkedList Node[i].data <= 1000, where SinglyLinkedList Node[i] is the i**th element of the linked list.
• 0 <= position <= n

Sample Input

3
16
13
7
1
2


Sample Output

16 13 1 7


Explanation

The initial linked list is 16 -> 13 -> 7. Insert 1 at the position 2 which currently has 7 in it. The updated linked list is 16 -> 13 -> 1 -> 7.

## Code Examples

### #1 Code Example with C Programming

Code - C Programming


#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int data;
};

};

node->data = node_data;
node->next = NULL;

return node;
}

} else {
}

}

while (node) {
fprintf(fptr, "%d", node->data);

node = node->next;

if (node) {
fprintf(fptr, "%s", sep);
}
}
}

while (node) {
node = node->next;

free(temp);
}
}

/*
* Complete the 'insertNodeAtPosition' function below.
*
* The function is expected to return an INTEGER_SINGLY_LINKED_LIST.
* The function accepts following parameters:
*  2. INTEGER data
*  3. INTEGER position
*/

/*
*
*     int data;
* };
*
*/

} else {
if(position == 0) {
temp->data = data;
return temp;
} else {
temp->data = data;
for(int i = 0; i < position-1; i++> {
prev = prev->next;
}
temp->next = prev->next;
prev->next = temp;
}
}
}

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

llist->tail = NULL;

char* llist_count_endptr;
int llist_count = strtol(llist_count_str, &llist_count_endptr, 10);

if (llist_count_endptr == llist_count_str || *llist_count_endptr != '\0') { exit(EXIT_FAILURE); }

for (int i = 0; i  <  llist_count; i++) {
char* llist_item_endptr;
int llist_item = strtol(llist_item_str, &llist_item_endptr, 10);

if (llist_item_endptr == llist_item_str || *llist_item_endptr != '\0') { exit(EXIT_FAILURE); }

}

char* data_endptr;
int data = strtol(data_str, &data_endptr, 10);

if (data_endptr == data_str || *data_endptr != '\0') { exit(EXIT_FAILURE); }

char* position_endptr;
int position = strtol(position_str, &position_endptr, 10);

if (position_endptr == position_str || *position_endptr != '\0') { exit(EXIT_FAILURE); }

char *sep = " ";

fprintf(fptr, "\n");

fclose(fptr);

return 0;
}

size_t alloc_length = 1024;
size_t data_length = 0;
char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) { break; }

data_length += strlen(cursor);

if (data_length  <  alloc_length - 1 || data[data_length - 1] == '\n') { break; }

size_t new_length = alloc_length << 1;
data = realloc(data, new_length);

if (!data) { break; }

alloc_length = new_length;
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';
}

data = realloc(data, data_length);

return data;
}

Copy The Code &

### #2 Code Example with C++ Programming

Code - C++ Programming


#include <bits/stdc++.h>

using namespace std;

public:
int data;

this->data = node_data;
this->next = nullptr;
}
};

public:

this->tail = nullptr;
}

void insert_node(int node_data) {

} else {
this->tail->next = node;
}

this->tail = node;
}
};

while (node) {
fout << node->data;

node = node->next;

if (node) {
fout << sep;
}
}
}

while (node) {
node = node->next;

free(temp);
}
}

for(int i=0;i < position-1;i++)
{
nh=nh->next;
}
t=nh->next ;
nh->next=temp;
temp->next=t;
}
int main()
{
ofstream fout(getenv("OUTPUT_PATH"));

int llist_count;
cin >> llist_count;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

for (int i = 0; i  <  llist_count; i++) {
int llist_item;
cin >> llist_item;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

llist->insert_node(llist_item);
}

int data;
cin >> data;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

int position;
cin >> position;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

fout << "\n";

fout.close();

return 0;
}

Copy The Code &

### #3 Code Example with Java Programming

Code - Java Programming


import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

public int data;

this.data = nodeData;
this.next = null;
}
}

this.tail = null;
}

public void insertNode(int nodeData) {

} else {
this.tail.next = node;
}

this.tail = node;
}
}

public static void printSinglyLinkedList(SinglyLinkedListNode node, String sep, BufferedWriter bufferedWriter) throws IOException {
while (node != null) {
bufferedWriter.write(String.valueOf(node.data));

node = node.next;

if (node != null) {
bufferedWriter.write(sep);
}
}
}

if (head == null) return null;
if (position == 0) {
return temp;
}
for (int i = 0; i <  position-1; i++) {
p = p.next;
}
p.next = temp;
temp.next = next;
}

private static final Scanner scanner = new Scanner(System.in);

public static void main(String[] args) throws IOException {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

int llistCount = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

for (int i = 0; i  <  llistCount; i++) {
int llistItem = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

llist.insertNode(llistItem);
}

int data = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

int position = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

bufferedWriter.newLine();

bufferedWriter.close();

scanner.close();
}
}

Copy The Code &

### #4 Code Example with Python Programming

Code - Python Programming


#!/bin/python3

import math
import os
import random
import re
import sys

def __init__(self, node_data):
self.data = node_data
self.next = None

def __init__(self):
self.tail = None

def insert_node(self, node_data):

else:
self.tail.next = node

self.tail = node

while node:
fptr.write(str(node.data))

node = node.next

if node:
fptr.write(sep)

#
# Complete the 'insertNodeAtPosition' function below.
#
# The function is expected to return an INTEGER_SINGLY_LINKED_LIST.
# The function accepts following parameters:
#  2. INTEGER data
#  3. INTEGER position
#

#
#
#     int data
#
#

class Node(object):

def __init__(self, data=None, next_node=None):
self.data = data
self.next = next_node

if position==0:
else: