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

|

697 Discussions

|

  • mdsanz
     + 0 comments

    My Java 8 Solution

    public static DoublyLinkedListNode reverse(DoublyLinkedListNode llist) {
        DoublyLinkedListNode reversedList = null, current = llist;
        
        while (current != null) {
            DoublyLinkedListNode temp = new DoublyLinkedListNode(current.data);
            
            if (reversedList == null) {
                reversedList = temp;
            } else {
                temp.next = reversedList;
                reversedList.prev = temp;
                reversedList = reversedList.prev;
            }
            current = current.next;
        }
        
        return reversedList;
    }

  • limkevinkuan
     + 0 comments

    PSA: DO NOT USE KOTLIN

    You cannot pass using Kotlin due to this issue, which still remains today.

  • emhhacker
     + 0 comments

    My Java solution with linear time complexity and constant space complexity:

     public static DoublyLinkedListNode reverse(DoublyLinkedListNode llist) {
        //return llist if its null, indicating the llist is empty
        if(llist == null) return llist;
        
        //use a curr ptr
        DoublyLinkedListNode curr = llist;
        
        //iterate thru the llist
        while(curr != null){
            //store curr nxt in a temp var
            DoublyLinkedListNode temp = curr.next;
            curr.next = curr.prev;
            curr.prev = temp;
            
            if(temp == null) break;
            else curr = temp;
        }
        return curr;        
    }

  • hayato
     + 0 comments

    my code in go

    func reverse(llist *DoublyLinkedListNode) *DoublyLinkedListNode {
    var last *DoublyLinkedListNode
    for llist != nil {        
        next := llist.next
        
        dumb := llist.prev
        llist.prev = llist.next
        llist.next = dumb
        last = llist
        llist = next
    }
    
    return last
}

  • kuro_ece
     + 0 comments

    reverse in place:

    DoublyLinkedListNode* reverse(DoublyLinkedListNode* llist) {
    DoublyLinkedListNode* cur = llist;
    DoublyLinkedListNode* rev = NULL;
    
    while(cur) {
        DoublyLinkedListNode* next = cur->next;
        cur->next = rev;
        rev = cur;
        cur = next;
        rev->prev = cur;
    }
    
    return rev;
}