travisdavies

 Profile Answers by travisdavies 

• Aug 24th, 2010

 

Swap the pointers (references) of the head and tail nodes win the list.

node swap = null;
swap = head;
head = tail;
tail = swap;

The next traversal through the list should be reversed.
      

DavidDilbert

 Profile Answers by DavidDilbert 

• Dec 5th, 2010

 

The prev. answer seemed pretty much on track, but wouldn't pass as an interview answer on the white board. Here's my equiv. Double check for stupid errors.

Code
pList  reverse(pList head){


    pList reversed, swap = null;


    while (head != null){


        swap = head;


        head = head.next;


        swap.next = reversed;


        reversed = swap;


    }


    return reversed;


}

nishkarshs

 Profile Answers by nishkarshs 

• Dec 30th, 2010

 

How to think: Make a 'temp' node similar to any other node. This has a 'next' element. So, all we need now is the 'prev' element. Hence, we create a pointer variable prev.

Algo:

Code
prev = NULL


node = head_node // the starting node of linked list


 


while (node.next != NULL) {


  temp = node


  node.next = prev


  prev = temp


  node = temp.next


}

// done!

Chirag

• Oct 11th, 2011

 

Here is the code

Code
#include <stdio.h>


typedef struct node mnode;


mnode* reverse_ll(mnode* head)


{


        if(head==NULL)


                return;


        mnode *temp1,*temp2,*temp3;


        


        


        temp2=head->next;


        head->next=NULL;


        while(temp2!=NULL)


        {


                temp3=temp2->next;


                temp2->next=head;


                head=temp2;


                temp2=temp3;


        }


        return head;


        


}

Shikhar Singhal

• Jun 10th, 2013

 

Code
list* reverse( list *head)


{


list *a=head,*Prev=NULL, *Next= NULL;


 


while (a.next!=NULL)


{


     Next=a.next;


     a.next=Prev;


     Prev= a;


     a=Next;


}


return *a;


}

usan007

 Profile Answers by usan007 

• Aug 8th, 2014

 

Code with comments for clarity

Code
        public Node reverse(Node head) {                


                // traverse the list 


                // make each node point to its previous node


                Node previous = null, current = head, next = null;              


                while (current != null) {


                        next = current.next;            // store next nodes pointer


                        current.next = previous;        // make current node point to previous node


                        previous = current;             // adjust previous for next iteration   (move previous to current)


                        current = next;                 // adjust current for next iteration    (move current to next)


                }


                return previous;


        }               

Eric Nantel

• Apr 22nd, 2015

 

Use a stack so when you pop you get the reverse order !!

Code
auto it = list->begin();


auto stack;


 


while(it != list->end())


{


      stack.push(it);


      it = it->next;


}


list->clear();


while( !stack.empty())


{


   list->insert(stack.pop());


}

Eric Nantel

• Apr 22nd, 2015

 

No ,it is said that this is a SINGLE-linked list , if you try head->next it points to head !

Asad

• Jun 7th, 2015

 

Code
public void reverse(Node node) {


    if (node.next == null) {


         head = node;


         return;


    }


    reverse(node.next);


    node.next.next = node;


    node.next = null;


}

Code2Live

• Jun 9th, 2015

 

Code
reverse(Node root)


{


  Node x = root;


  if (x != null)


  {


    Stack<Node> nodes = new Stack<Node>();


    while(x != null)


    {


      nodes.push(x);


      x = x.next;


    }


    


    root = nodes.pop();


    x = root;


    while(!nodes.isEmpty())


   {


      x.next = nodes.pop();


      x = x.next;


    }