## Algorithm

Problem Name: Data Structures - Reverse a doubly linked list

In this HackerRank in Data Structures - Reverse a doubly linked list solutions

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.

Note: The head node might be NULL to indicate that the list is empty.

Function Description

Complete the reverse function in the editor below.

reverse has the following parameter(s):

Returns

Input Format

The first line contains an integer t, the number of test cases.

Each test case is of the following format:

• The first line contains an integer n, the number of elements in the linked list.
• The next n lines contain an integer each denoting an element of the linked list.

Constraints

• 1 <= t <= 10
• 0 <= n <= 1000
• 0 <= DoublyLinkedListNode.data <= 1000

Output Format

Return a reference to the head of your reversed list. The provided code will print the reverse array as a one line of space-separated integers for each test case.

Sample Input

1
4
1
2
3
4

Sample Output

4 3 2 1

Explanation

The initial doubly linked list is: 1 <-> 2 <-> 3 <-> 4 -> NULL

The reversed doubly linked list is: 4 <-> 3 <-> 2 <-> 1 -> NULL

## 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;
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.
*
* The function is expected to return an INTEGER_DOUBLY_LINKED_LIST.
* The function accepts INTEGER_DOUBLY_LINKED_LIST llist as parameter.
*/

/*
*
*     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;
}
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;
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;
}
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.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();
}
}
Copy The Code &

### #4 Code Example with Javascript Programming

Code - 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.
*
* The function is expected to return an INTEGER_DOUBLY_LINKED_LIST.
* The function accepts INTEGER_DOUBLY_LINKED_LIST llist as parameter.
*/

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

ws.write("\n");
}

ws.end();
}
Copy The Code &

### #5 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
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.
#
# The function is expected to return an INTEGER_DOUBLY_LINKED_LIST.
# The function accepts INTEGER_DOUBLY_LINKED_LIST llist as parameter.
#

#
#
#     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)