We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Data Structures
  3. Linked Lists
  4. Reverse a doubly linked list
  5. Discussions

Reverse a doubly linked list

Sort by

recency

|

692 Discussions

|

  • mirzashahbazbai1
     + 0 comments

    this is my solution def reverse(llist): # Write your code here current=llist prev_node=None while current: current.prev,current.next = current.next,current.prev prev_node = current current = current.prev

    return prev_node

  • Lonchik
     + 0 comments

    geeze hackerrankk, fix your C# templates!!!!!!!!!!!!!!!!

    remove class result but keep its guts. Change function to not be public.

  • minh270605
     + 0 comments

    My code in c++:

    DoublyLinkedListNode* reverse(DoublyLinkedListNode* llist) {
    if(llist == NULL) return NULL;
    else if(llist->next == NULL) return llist;
   ``
    DoublyLinkedListNode* re = new DoublyLinkedListNode(llist->data);
    llist = llist->next;
    while(llist != NULL){
        DoublyLinkedListNode* x = new DoublyLinkedListNode(llist->data);
        x->next = re;
        re->prev = x;
        re = x;

        llist = llist->next;
}
return re;

    }

  • romaizdabeer57
     + 0 comments

    This is the easiest and most efficient way I've found to reverse a doubly linked list in python 3

    #!/bin/python3

import math
import os
import random
import re
import sys

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

class DoublyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None

    def insert_node(self, node_data):
        node = DoublyLinkedListNode(node_data)

        if not self.head:
            self.head = node
        else:
            self.tail.next = node
            node.prev = self.tail


        self.tail = node

def print_doubly_linked_list(node, sep, fptr):
    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.
#

#
# For your reference:
#
# DoublyLinkedListNode:
#     int data
#     DoublyLinkedListNode next
#     DoublyLinkedListNode prev
#
#

def reverse(head):
    # Write your code here
    if head is None:
        return None
    curr = head
    while curr:
        curr.prev, curr.next = curr.next, curr.prev
        head = curr
        curr = curr.prev
    return head

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

    t = int(input())

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

        llist = DoublyLinkedList()

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

        llist1 = reverse(llist.head)

        print_doubly_linked_list(llist1, ' ', fptr)
        fptr.write('\n')

    fptr.close()

  • jhakim101
     + 0 comments
    def reverse(llist):
    head = llist
    last = None    # hold onto last visited note
    while head:
		
        tmp = head.next
        head.next = head.prev
        head.prev = tmp
				
        last = head
        head = tmp
    return last