HackerRank Reverse a doubly linked list problem solution

In this HackerRank Reverse a doubly linked list Interview preparation kit problem You have Given the pointer to the head node of a doubly-linked list, reverse the order of the nodes in place. That is, change the next and prev pointers of the nodes so that the direction of the list is reversed. Return a reference to the head node of the reversed list.

Problem solution in 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
self.prev = None

def __init__(self):
self.tail = None

def insert_node(self, node_data):

else:
self.tail.next = node
node.prev = self.tail

self.tail = node

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

node = node.next

if node:
fptr.write(sep)

# Complete the reverse function below.

#
#
#     int data
#
#

while True:

break

if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')

t = int(input())

for t_itr in range(t):
llist_count = int(input())

for _ in range(llist_count):
llist_item = int(input())
llist.insert_node(llist_item)

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 {

public int data;

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

this.tail = null;
}

public void insertNode(int nodeData) {

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

this.tail = node;
}
}

public static void printDoublyLinkedList(DoublyLinkedListNode 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);
}
}
}

// Complete the reverse function below.

/*
*
*     int data;
* }
*
*/
curr.next = curr.prev;
curr.prev = temp;
return temp == null ? curr : reverse(temp);
}

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 t = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

for (int tItr = 0; tItr < t; tItr++) {

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);
}

bufferedWriter.newLine();
}

bufferedWriter.close();

scanner.close();
}
}

Problem solution in C++ programming.

#include <bits/stdc++.h>

using namespace std;

public:
int data;

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

public:

this->tail = nullptr;
}

void insert_node(int node_data) {

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

this->tail = node;
}
};

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

node = node->next;

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

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

free(temp);
}
}

// Complete the reverse function below.

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

{
// Complete this function
// Do not write the main method.

while ( current != NULL) {
temp = current -> prev;
current -> prev =  current -> next;
current -> next = temp;
current =  current -> prev;

}

if (temp != NULL)

}

int main()
{
ofstream fout(getenv("OUTPUT_PATH"));

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

for (int t_itr = 0; t_itr < t; t_itr++) {

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);
}

fout << "\n";

}

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>

int data;
};

};

node->data = node_data;
node->next = NULL;
node->prev = 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 reverse function below.

/*
*
*     int data;
* };
*
*/
while (curr != NULL) {
next = curr->next;
curr->next = prev;
curr->prev = next;
prev = curr;
curr = next;
}
return prev;
}

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

char* t_endptr;
int t = strtol(t_str, &t_endptr, 10);

if (t_endptr == t_str || *t_endptr != '\0') { exit(EXIT_FAILURE); }

for (int t_itr = 0; t_itr < t; t_itr++) {
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 *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;
}

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();
});

return inputString[currentLine++];
}

constructor(nodeData) {
this.data = nodeData;
this.next = null;
this.prev = null;
}
};

constructor() {
this.tail = null;
}

insertNode(nodeData) {

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

this.tail = node;
}
};

while (node != null) {
ws.write(String(node.data));

node = node.next;

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

// Complete the reverse function below.

/*
*
*     int data;
* }
*
*/
while(current) {
var curNext = current.next;
current.next = current.prev;
current.prev = curNext;
if (curNext) {
current = curNext;
}
else {
return current;
}
}
}

function main() {
const ws = fs.createWriteStream(process.env.OUTPUT_PATH);

for (let tItr = 0; tItr < t; tItr++) {

for (let i = 0; i < llistCount; i++) {
llist.insertNode(llistItem);
}