In this HackerRank Insert, a node at a specific position in a linked list Interview preparation kit problem You have 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.
Problem solution in Python programming.
#!/bin/python3
import math
import os
import random
import re
import sys
class SinglyLinkedListNode:
def __init__(self, node_data):
self.data = node_data
self.next = None
class SinglyLinkedList:
def __init__(self):
self.head = None
self.tail = None
def insert_node(self, node_data):
node = SinglyLinkedListNode(node_data)
if not self.head:
self.head = node
else:
self.tail.next = node
self.tail = node
def print_singly_linked_list(node, sep, fptr):
while node:
fptr.write(str(node.data))
node = node.next
if node:
fptr.write(sep)
# Complete the insertNodeAtPosition function below.
#
# For your reference:
#
# SinglyLinkedListNode:
# int data
# SinglyLinkedListNode next
#
#
class Node(object):
def __init__(self, data=None, next_node=None):
self.data = data
self.next = next_node
def insertNodeAtPosition(head, data, position):
if position==0:
head = Node(data,head)
return head
else:
temp_head = head
while position>1:
temp_head = temp_head.next
position = position -1
temp_head.next = Node(data,temp_head.next)
return head
if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')
llist_count = int(input())
llist = SinglyLinkedList()
for _ in range(llist_count):
llist_item = int(input())
llist.insert_node(llist_item)
data = int(input())
position = int(input())
llist_head = insertNodeAtPosition(llist.head, data, position)
print_singly_linked_list(llist_head, ' ', fptr)
fptr.write('n')
fptr.close()
Problem solution in 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 {
static class SinglyLinkedListNode {
public int data;
public SinglyLinkedListNode next;
public SinglyLinkedListNode(int nodeData) {
this.data = nodeData;
this.next = null;
}
}
static class SinglyLinkedList {
public SinglyLinkedListNode head;
public SinglyLinkedListNode tail;
public SinglyLinkedList() {
this.head = null;
this.tail = null;
}
public void insertNode(int nodeData) {
SinglyLinkedListNode node = new SinglyLinkedListNode(nodeData);
if (this.head == null) {
this.head = node;
} 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);
}
}
}
static SinglyLinkedListNode insertNodeAtPosition(SinglyLinkedListNode head, int data, int position) {
if (head == null) return null;
SinglyLinkedListNode temp = new SinglyLinkedListNode(data);
if (position == 0) {
temp.next = head;
return temp;
}
SinglyLinkedListNode p = head;
for (int i = 0; i< position-1; i++) {
p = p.next;
}
SinglyLinkedListNode next = p.next;
p.next = temp;
temp.next = next;
return head;
}
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")));
SinglyLinkedList llist = new SinglyLinkedList();
int llistCount = scanner.nextInt();
scanner.skip("(rn|[nru2028u2029u0085])?");
for (int i = 0; i < llistCount; i++) {
int llistItem = scanner.nextInt();
scanner.skip("(rn|[nru2028u2029u0085])?");
llist.insertNode(llistItem);
}
int data = scanner.nextInt();
scanner.skip("(rn|[nru2028u2029u0085])?");
int position = scanner.nextInt();
scanner.skip("(rn|[nru2028u2029u0085])?");
SinglyLinkedListNode llist_head = insertNodeAtPosition(llist.head, data, position);
printSinglyLinkedList(llist_head, " ", bufferedWriter);
bufferedWriter.newLine();
bufferedWriter.close();
scanner.close();
}
}
Problem solution in C++ programming.
#include <bits/stdc++.h>
using namespace std;
class SinglyLinkedListNode {
public:
int data;
SinglyLinkedListNode *next;
SinglyLinkedListNode(int node_data) {
this->data = node_data;
this->next = nullptr;
}
};
class SinglyLinkedList {
public:
SinglyLinkedListNode *head;
SinglyLinkedListNode *tail;
SinglyLinkedList() {
this->head = nullptr;
this->tail = nullptr;
}
void insert_node(int node_data) {
SinglyLinkedListNode* node = new SinglyLinkedListNode(node_data);
if (!this->head) {
this->head = node;
} else {
this->tail->next = node;
}
this->tail = node;
}
};
void print_singly_linked_list(SinglyLinkedListNode* node, string sep, ofstream& fout) {
while (node) {
fout << node->data;
node = node->next;
if (node) {
fout << sep;
}
}
}
void free_singly_linked_list(SinglyLinkedListNode* node) {
while (node) {
SinglyLinkedListNode* temp = node;
node = node->next;
free(temp);
}
}
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;
}
int main()
{
ofstream fout(getenv("OUTPUT_PATH"));
SinglyLinkedList* llist = new SinglyLinkedList();
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');
SinglyLinkedListNode* llist_head = insertNodeAtPosition(llist->head, data, position);
print_singly_linked_list(llist_head, " ", fout);
fout << "n";
free_singly_linked_list(llist_head);
fout.close();
return 0;
}
Problem solution in 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>
char* readline();
typedef struct SinglyLinkedListNode SinglyLinkedListNode;
typedef struct SinglyLinkedList SinglyLinkedList;
struct SinglyLinkedListNode {
int data;
SinglyLinkedListNode* next;
};
struct SinglyLinkedList {
SinglyLinkedListNode* head;
SinglyLinkedListNode* tail;
};
SinglyLinkedListNode* create_singly_linked_list_node(int node_data) {
SinglyLinkedListNode* node = malloc(sizeof(SinglyLinkedListNode));
node->data = node_data;
node->next = NULL;
return node;
}
void insert_node_into_singly_linked_list(SinglyLinkedList** singly_linked_list, int node_data) {
SinglyLinkedListNode* node = create_singly_linked_list_node(node_data);
if (!(*singly_linked_list)->head) {
(*singly_linked_list)->head = node;
} else {
(*singly_linked_list)->tail->next = node;
}
(*singly_linked_list)->tail = node;
}
void print_singly_linked_list(SinglyLinkedListNode* node, char* sep, FILE* fptr) {
while (node) {
fprintf(fptr, "%d", node->data);
node = node->next;
if (node) {
fprintf(fptr, "%s", sep);
}
}
}
void free_singly_linked_list(SinglyLinkedListNode* node) {
while (node) {
SinglyLinkedListNode* temp = node;
node = node->next;
free(temp);
}
}
SinglyLinkedListNode* insertNodeAtPosition(SinglyLinkedListNode* head, int data, int position) {
SinglyLinkedListNode* temp = (SinglyLinkedListNode*)malloc(sizeof(SinglyLinkedListNode));
if(head == NULL) {
head->data = data;
head->next = NULL;
return head;
} else {
if(position == 0) {
temp->data = data;
temp->next = head;
return temp;
} else {
SinglyLinkedListNode* prev = head;
temp->data = data;
for(int i = 0; i < position-1; i++) {
prev = prev->next;
}
temp->next = prev->next;
prev->next = temp;
}
}
return head;
}
int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");
SinglyLinkedList* llist = malloc(sizeof(SinglyLinkedList));
llist->head = NULL;
llist->tail = NULL;
char* llist_count_endptr;
char* llist_count_str = readline();
int llist_count = strtol(llist_count_str, &llist_count_endptr, 10);
if (llist_count_endptr == llist_count_str || *llist_count_endptr != ' ') { exit(EXIT_FAILURE); }
for (int i = 0; i < llist_count; i++) {
char* llist_item_endptr;
char* llist_item_str = readline();
int llist_item = strtol(llist_item_str, &llist_item_endptr, 10);
if (llist_item_endptr == llist_item_str || *llist_item_endptr != ' ') { exit(EXIT_FAILURE); }
insert_node_into_singly_linked_list(&llist, llist_item);
}
char* data_endptr;
char* data_str = readline();
int data = strtol(data_str, &data_endptr, 10);
if (data_endptr == data_str || *data_endptr != ' ') { exit(EXIT_FAILURE); }
char* position_endptr;
char* position_str = readline();
int position = strtol(position_str, &position_endptr, 10);
if (position_endptr == position_str || *position_endptr != ' ') { exit(EXIT_FAILURE); }
SinglyLinkedListNode* llist_head = insertNodeAtPosition(llist->head, data, position);
char *sep = " ";
print_singly_linked_list(llist_head, sep, fptr);
fprintf(fptr, "n");
free_singly_linked_list(llist_head);
fclose(fptr);
return 0;
}
char* readline() {
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] = ' ';
}
data = realloc(data, data_length);
return data;
}
Problem solution in JavaScript programming.
'use strict';
const fs = require('fs');
process.stdin.resume();
process.stdin.setEncoding('utf-8');
let inputString = '';
let currentLine = 0;
process.stdin.on('data', inputStdin => {
inputString += inputStdin;
});
process.stdin.on('end', _ => {
inputString = inputString.replace(/s*$/, '')
.split('n')
.map(str => str.replace(/s*$/, ''));
main();
});
function readLine() {
return inputString[currentLine++];
}
const SinglyLinkedListNode = class {
constructor(nodeData) {
this.data = nodeData;
this.next = null;
}
};
const SinglyLinkedList = class {
constructor() {
this.head = null;
this.tail = null;
}
insertNode(nodeData) {
const node = new SinglyLinkedListNode(nodeData);
if (this.head == null) {
this.head = node;
} else {
this.tail.next = node;
}
this.tail = node;
}
};
function printSinglyLinkedList(node, sep, ws) {
while (node != null) {
ws.write(String(node.data));
node = node.next;
if (node != null) {
ws.write(sep);
}
}
}
// Complete the insertNodeAtPosition function below.
/*
* For your reference:
*
* SinglyLinkedListNode {
* int data;
* SinglyLinkedListNode next;
* }
*
*/
function insert(head, data, position) {
var newNode = new Node(data);
var current = head;
if (position === 0) {
newNode.next = current;
return head = newNode;
};
var counter, previous, temp;
counter = 0;
while (counter < position && current) {
previous = current;
current = current.next;
counter++;
};
current
temp = previous.next;
previous.next = newNode;
newNode.next = temp;
return head;
};
function main() {
const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
const llistCount = parseInt(readLine(), 10);
let llist = new SinglyLinkedList();
for (let i = 0; i < llistCount; i++) {
const llistItem = parseInt(readLine(), 10);
llist.insertNode(llistItem);
}
const data = parseInt(readLine(), 10);
const position = parseInt(readLine(), 10);
let llist_head = insertNodeAtPosition(llist.head, data, position);
printSinglyLinkedList(llist_head, " ", ws)
ws.write("n");
ws.end();
}
All your codings are not opening for some problems
am working on it
java solution is wrong…..you didn't wrote the required function….. "insertNodeAtPosition(llist.head, data, position)"
fix in 24 hours
now fixed you can use it