How to reverse a singly linked list using only two pointers

Question

I wonder if there exists some logic to reverse a singly-linked list using only two pointers   The following is used to reverse the single linked list using three pointers namely p  q  r   struct node       int data      struct node  link      void reverse         struct node  p   first                   q   NULL                   r       while  p    NULL            r   q          q   p          p   p- gt link          q- gt link   r            first   q      Is there any other alternate to reverse the linked list   What would be the best logic to reverse a singly linked list  in terms of time complexity

User · Answer

Yes there is a way using only two pointers  That is by creating new linked list where the first node is the first node of the given list and second node of the first list is added at the start of the new list and so on

User · Answer

here is a little simple solution     void reverse         node   pointer1   head- gt next      if pointer1    NULL                node  pointer2   pointer1- gt next          pointer1- gt next   head          head- gt next   NULL          head   pointer1           if pointer2    NULL                         while pointer2    NULL                                pointer1   pointer2                  pointer2   pointer2- gt next                  pointer1- gt next   head                  head   pointer1                             pointer1- gt next   head              head   pointer1

User · Answer

Here is my version   void reverse ListElem   amp head        ListElem  temp      ListElem  elem   head- gt next        ListElem  prev   head      head- gt next 0        while temp   elem- gt next                  elem- gt next prev           prev   elem          elem   temp            elem- gt next prev       head   elem      where  class ListElem  public      ListElem int val    val val        ListElem  next   const   return  next        void next ListElem  elem     next   elem        void val int val    val   val        int val   const   return  val   private      ListElem   next      int  val

User · Answer

Robert Sedgewick   Algorithms in C   Addison-Wesley  3rd Edition  1997   Section 3 4   In case that is not a cyclic list  hence NULL is the last link  typedef struct node  link   struct node      int item      link next         you send the existing list to reverse   and returns the reversed one     link reverse link x       link t  y   x  r   NULL      while y    NULL           t   y- next          y-  next   r          r   y          y   t            return r

User · Answer

I have a slightly different approach  I wanted to make use of the existing functions  like insert at index   delete from index   to reverse the list  something like a right shift operation   The complexity is still O n  but the advantage is more reused code  Have a look at another reverse   method and let me know what you all think    include  lt stdio h gt   include  lt stdlib h gt   struct node       int data      struct node  next      struct node  head   NULL   void printList char  msg        struct node  current   head       printf   n s n   msg        while  current    NULL            printf   d    current- gt data           current   current- gt next           void insert beginning int data        struct node  newNode    struct node   malloc sizeof struct node         newNode- gt data   data      newNode- gt next   NULL       if  head    NULL                head   newNode        else           newNode- gt next   head          head   newNode           void insert at int data  int location         struct node  newNode    struct node   malloc sizeof struct node         newNode- gt data   data      newNode- gt next   NULL       if  head    NULL                head   newNode             else           struct node  currentNode   head          int index   0           while  currentNode    NULL  amp  amp  index  lt   location - 1                 currentNode   currentNode- gt next              index                       if  currentNode    NULL                        if  location    0                    newNode- gt next   currentNode                  head   newNode                else                   newNode- gt next   currentNode- gt next                  currentNode- gt next   newNode                                    int delete from int location         int retValue   -1       if  location  lt  0    head    NULL                printf   nList is empty or invalid index            return -1        else            struct node  currentNode   head          int index   0           while  currentNode    NULL  amp  amp  index  lt   location - 1                 currentNode   currentNode- gt next              index                       if  currentNode    NULL                           we ve reached the node just one prior to the one we want to delete              if  location    0                     if  currentNode- gt next    NULL                                           this is the only node in the list                     retValue   currentNode- gt data                      free currentNode                       head   NULL                    else                           the next node should take its place                     struct node  nextNode   currentNode- gt next                      head   nextNode                      retValue   currentNode- gt data                      free currentNode                                      if  location    0              else                      the next node should take its place                 struct node  nextNode   currentNode- gt next                  currentNode- gt next   nextNode- gt next                   if  nextNode    NULL                                         retValue   nextNode- gt data                      free nextNode                                              else               printf   nInvalid index                return -1                       return retValue     void another reverse         if  head    NULL                printf   nList is empty n            return        else              get the tail pointer          struct node  tailNode   head          int index   0  counter   0           while  tailNode- gt next    NULL                tailNode   tailNode- gt next              index                          now tailNode points to the last node         while  counter    index                int data   delete from index               insert at data  counter               counter                       int main int argc  char   argv         insert beginning 4       insert beginning 3       insert beginning 2       insert beginning 1       insert beginning 0            insert at 5  0        insert at 4  1        insert at 3  2        insert at 1  1          printList  Original List 0           reverse list        another reverse         printList  Reversed List 0             delete from 2        delete from 2            printList        return 0

User · Answer

Here s the code to reverse a singly linked list in C   And here it is pasted below      reverse c   include  lt stdio h gt   include  lt assert h gt   typedef struct node Node  struct node       int data      Node  next      void spec reverse    Node  reverse Node  head    int main         spec reverse        return 0     void print Node  head        while  head            printf    d - gt    head- gt data           head   head- gt next            printf  NULL n       void spec reverse            Create a linked list          0 - gt  1 - gt  2 - gt NULL     Node node2    2  NULL       Node node1    1   amp node2       Node node0    0   amp node1       Node  head    amp node0       print head       head   reverse head       print head        assert head     amp node2       assert head- gt next     amp node1       assert head- gt next- gt next     amp node0        printf  Passed           Step 1        prev head  next                       v    v    v    NULL   0 - gt  1 - gt  2 - gt NULL       Step 2             prev head  next                                 v    v    v    NULL lt - 0    1 - gt  2 - gt NULL    Node  reverse Node  head        Node  prev   NULL      Node  next       while  head            next   head- gt next          head- gt next   prev          prev   head          head   next             return prev

User · Answer

using 2-pointers    bit large but simple and efficient  void reverse       int n 0   node  temp  temp1   temp strptr   while temp- gt next  NULL      n           counting no  of nodes  temp temp- gt next        we will exchange ist by last     2nd by 2nd last so on     int i n 2     temp strptr   for int j 1 j lt   n-i 1  j     temp temp- gt next      i started exchanging from in between     so we do no have to traverse list so far   again and again for exchanging  while i gt 0      temp1 strptr   for int j 1 j lt  i j     this loop for traversing nodes before n 2  temp1 temp1- gt next   int t   t temp1- gt info   temp1- gt info temp- gt info   temp- gt info t   i--   temp temp- gt next      at the end after exchanging say 2 and 4 in a 5 node list    temp will be at 5 and we will traverse temp1 to ist node and exchange

User · Answer

include  lt stdio h gt   include  lt malloc h gt   tydef struct node       int info      struct node  link     start   void main         rev       void rev         struct node  p   start   q   NULL   r      while  p    NULL                r   q          q   p          p   p- gt link          q- gt link   r             start   q

User · Answer

Any alternative   No  this is as simple as it gets  and there s no fundamentally-different way of doing it   This algorithm is already O n  time  and you can t get any faster than that  as you must modify every node   It looks like your code is on the right track  but it s not quite working in the form above   Here s a working version    include  lt stdio h gt   typedef struct Node     char data    struct Node  next    Node   void print list Node  root      while  root        printf   c    root- gt data       root   root- gt next        printf   n       Node  reverse Node  root      Node  new root   0    while  root        Node  next   root- gt next      root- gt next   new root      new root   root      root   next        return new root     int main       Node d      d   0      Node c      c    amp d      Node b      b    amp c      Node a      a    amp b       Node  root    amp a    print list root     root   reverse root     print list root      return 0

User · Answer

You can simply reverse a Linked List using only one Extra pointer  And the key to do this is by using a Recursion  Here is the program in Java  public class Node      public int data     public Node next     public Node reverseLinkedListRecursion Node p        if  p next    null            head   p          q   p          return q        else           reverseLinkedListRecursion p next           p next   null          q next   p          q   p          return head              call this function from your main method   reverseLinkedListRecursion head    As you can see this is a simple example of a head recursion  We have mainly two different kinds of Recursion   Head Recursion - When the Recursion is the first thing executed by a function  Tail Recursion - When the Recursion is the last thing executed by a function   Here the program will keep calling itself Recursively until our Pointer  quot p quot  reaches to the last node and then before returning the stack frame we will point head to the last node and the extra Pointer  quot q quot  to build the linked list in the backward direction  Here the Stack Frames will keep on returning until the stack is empty

User · Answer

with this no extra space and no extra scans but this code is reversing code but read    in reverse direction no changes made in the linked list  PrintInReverse Node node          given list is null    if node   null         return null        if list contains only one node    if node- gt next   null              print node value             call recursively     else               while node- gt next    null    due to while loop it goes into infinite loop use   if        if node- gt next  NULL                      PrintInReverse node- gt next             print node value                   Add comments

User · Answer

I don t understand why there is need to return head as we are passing it as argument  We are passing head of the link list then we can update also  Below is simple solution     include lt stdio h gt   include lt conio h gt   struct NODE       struct NODE  next      int value      typedef struct NODE node   void reverse node   head   void add end node   head int val   void alloc node   p   void print all node  head    void main         node  head      clrscr        head   NULL      add end   amp head  1        add end   amp head  2        add end   amp head  3        print all  head        reverse   amp head        print all  head        getch      void alloc node   p        node  temp      temp    node    malloc  sizeof node           temp- gt next   NULL       p   temp    void add end node   head int val        node  temp  new node      alloc  amp new node       new node- gt value   val      if   head    NULL                  head   new node          return            for temp    head temp- gt next  NULL temp temp- gt next       temp- gt next   new node    void print all node  head        node  temp      int index 0      printf    n n        if  head    NULL                printf    List is Empty  n            return            for  temp head  temp    NULL  temp temp- gt next index            printf     d    gt   d  n  index temp- gt value     void reverse node   head        node  next  new head      new head NULL      while  head    NULL                next     head - gt next            head - gt next   new head          new head     head             head    next              head  new head

User · Answer

Here s a simpler version in Java  It does use only two pointers curr  amp  prev  public void reverse Node head        Node curr   head  prev   null       while  head next    null            head   head next     move the head to next node         curr next   prev    break the link to the next node and assign it to previous         prev   curr          we are done with previous  move it to next node         curr   head          current moves along with head            head next   prev        for last node

User · Answer

You can go for recursive approach   Here is the pseudo code   Node  reverse Node  root        if  root  return NULL       if   root- gt next   temp   root      else               reverse root- gt next           root- gt next- gt next   root          root- gt next   NULL             return temp      After the call is made to the function  it returns the new root temp  of the linked list  As it is very clear that it makes use of only two pointers

User · Answer

Using two pointers while maintaining time complexity of O n   the fastest achievable  might only be possible through number casting of pointers and swapping their values  Here is an implementation    include  lt stdio h gt   typedef struct node       int num      struct node  next   node   void reverse node  head       node  ptr     if  head     head- gt next     head- gt next- gt next  return     ptr   head- gt next- gt next     head- gt next- gt next   NULL     while ptr               Swap head- gt next and ptr          head- gt next    unsigned  ptr          unsigned ptr    unsigned  head- gt next          unsigned head- gt next    unsigned ptr      unsigned head- gt next           Swap head- gt next- gt next and ptr          head- gt next- gt next    unsigned  ptr          unsigned ptr    unsigned  head- gt next- gt next          unsigned head- gt next- gt next    unsigned ptr      unsigned head- gt next- gt next          void add end node  ptr  int n        while ptr- gt next  ptr   ptr- gt next      ptr- gt next   malloc sizeof node        ptr- gt next- gt num   n      ptr- gt next- gt next   NULL     void print node  ptr        while ptr   ptr- gt next  printf   d    ptr- gt num       putchar   n       void erase node  ptr        node  end      while ptr- gt next                if ptr- gt next- gt next  ptr   ptr- gt next          else                       end   ptr- gt next              ptr- gt next   NULL              free end                      void main         int i  n   5      node  dummy head      dummy head- gt next   NULL      for i   1  i  lt   n     i  add end dummy head  i       print dummy head       reverse dummy head       print dummy head       erase dummy head

User · Answer

Following is one implementation using 2 pointers  head and r   ListNode   reverse ListNode  head         ListNode  r   NULL       if head            r   head- gt next          head- gt next   NULL             while r            head   reinterpret cast lt ListNode  gt  size t head    size t r- gt next            r- gt next   reinterpret cast lt ListNode  gt  size t r- gt next    size t head            head   reinterpret cast lt ListNode  gt  size t head    size t r- gt next             head   reinterpret cast lt ListNode  gt  size t head    size t r            r   reinterpret cast lt ListNode  gt  size t r    size t head            head   reinterpret cast lt ListNode  gt  size t head    size t r              return head

User · Answer

include  lt stddef h gt   typedef struct Node       struct Node  next      int data    Node   Node   reverse Node  cur        Node  prev   NULL      while  cur            Node  temp   cur          cur   cur- gt next     advance cur         temp- gt next   prev          prev   temp     advance prev           return prev

User · Answer

You can have solution of this problem with help of only one extra pointer  that has to be static for the reverse function  It s in O n  complexity    include lt stdio h gt   include lt stdlib h gt   typedef struct List  List  struct List      int val     List next      List reverse List list       with recursion and one static variable       static List tail      if  list     list- gt next            tail   list           return tail        else           reverse1 list- gt next           list- gt next- gt next   list          list- gt next   NULL           return tail

User · Answer

Here is a slightly different  but simple approach in C  11    include  lt iostream gt   struct Node      Node    next NULL        Node  next      std  string data      void printlist Node  l       while l           std  cout lt  lt l- gt data lt  lt std  endl          l   l- gt next            std  cout lt  lt  ----  lt  lt std  endl     void reverse Node  amp  l        Node  prev   NULL      while l           auto next   l- gt next          l- gt next   prev          prev l          l next            l   prev     int main         Node s t u v      s data    1       t data    2       u data    3       v data    4       s next    amp t      t next    amp u      u next    amp v      Node  ptr    amp s      printlist ptr       reverse ptr       printlist ptr       return 0      Output here

User · Answer

curr   head  prev   NULL   while  curr    NULL        next   curr- gt next     store current s next  since it will be overwritten     curr- gt next   prev      prev   curr      curr   next     head   prev     update head

User · Answer

You need a track pointer which will track the list   You need two pointers    first pointer  to pick first node   second pointer to pick second node     Processing    Move Track Pointer  Point second node to first node  Move First pointer one step  by assigning second pointer to one  Move Second pointer one step  By assigning Track pointer to second  Node  reverselist         Node  first   NULL      To keep first node    Node  second   head     To keep second node    Node  track    head     Track the list      while track  NULL              track   track- gt next     track point to next node        second- gt next   first     second node point to first       first   second     move first node to next       second   track     move second node to next            track   first       return track

User · Answer

A simple algorithm if you use the linked list as a stack structure     include  lt stdio h gt   include  lt stdlib h gt   typedef struct list       int key      char value      struct list  next    list  void print list    void add list    int  char   void reverse list     void deleteList list     int main void        list  head   NULL      int i 0      while   i    lt  26   add  amp head  i  i  a        printf  Before reverse   n        print head       printf  After reverse   n        reverse  amp head       print head       deleteList head      void deleteList list  l         list  t   l          while   t    NULL             list  tmp   t          t   t- gt next          free tmp            void print list  l        list  t   l      while   t    NULL            printf   d  c n   t- gt key  t- gt value           t   t- gt next           void reverse list   head        list  tmp    head      list  reversed   NULL      while   tmp    NULL             add  amp reversed  tmp- gt key  tmp- gt value           tmp   tmp- gt next            deleteList  head        head   reversed     void add list   head  int k  char v         list  t   calloc 1  sizeof list        t- gt key   k  t- gt value   v      t- gt next    head       head   t       The performance may be affected since additional function call to the add and malloc so the algorithms of address swaps are better but that one actually creates new list so you can use additional options like sort or remove items if you add a callback function as parameter to the reverse

User · Answer

To swap two variables without the use of a temporary variable   a   a xor b b   a xor b a   a xor b   fastest way is to write it in one line  a   a   b    b a    Similarly   using two swaps  swap a b  swap b c    solution using xor  a   a b c b   a b c c   a b c a   a b c   solution in one line  c   a   b   c    a b     b c  b   a   b   c    c a     a b  a   a   b   c    b c     c a    The same logic is used to reverse a linked list   typedef struct List    int info   struct List  next   List    List  reverseList List  head     p head   q p- gt next   p- gt next NULL   while q         q    List     int p    int q    int q- gt next    int  q- gt next p     int  p q        head   p   return head

User · Answer

No  nothing faster than the current O n  can be done  You need to alter every node  so time will be proportional to the number of elements anyway and that s O n  you already have

User · Answer

I am using java to implement this and approach is test driven development hence test cases are also attached    The Node class that represent single node -  package com adnan linkedlist          User    Adnan    Email   sendtoadnan gmail com    Date    9 21 13    Time    12 02 PM     public class Node        public Node int value  Node node           this value   value          this node   node            private int value      private Node node       public int getValue             return value             public Node getNode             return node             public void setNode Node node           this node   node            Service class that takes start node as input and reserve it without using extra space   package com adnan linkedlist          User    Adnan    Email   sendtoadnan gmail com    Date    9 21 13    Time    11 54 AM     public class SinglyLinkedListReversal        private static final SinglyLinkedListReversal service    new SinglyLinkedListReversal        public static SinglyLinkedListReversal getService            return service               public Node reverse Node start           if  hasOnlyNodeInLinkedList start                return start                    Node firstNode  secondNode  thirdNode          firstNode   start          secondNode   firstNode getNode            while  secondNode    null                thirdNode   secondNode getNode                secondNode setNode firstNode               firstNode   secondNode              secondNode   thirdNode                    start setNode null           return firstNode             private boolean hasOnlyNodeInLinkedList Node start            return start getNode      null              And The test case that covers above scenario  Please note that you require junit jars  I am using testng jar  you can use any whatever pleases you    package com adnan linkedlist   import org testng annotations Test   import static org testng AssertJUnit assertTrue          User    Adnan    Email   sendtoadnan gmail com    Date    9 21 13    Time    12 11 PM     public class SinglyLinkedListReversalTest        private SinglyLinkedListReversal reversalService    SinglyLinkedListReversal getService          Test     public void test reverseSingleElement   throws Exception           Node node   new Node 1  null           reversalService reverse node           assertTrue node getNode      null           assertTrue node getValue      1                 original - Node1 1  - gt  Node2 2  - gt  Node3 3        reverse - Node3 3  - gt  Node2 2  - gt  Node1 1       Test     public void test reverseThreeElement   throws Exception           Node node3   new Node 3  null           Node node2   new Node 2  node3           Node start   new Node 1  node2             start   reversalService reverse start           Node test   start          for  int i   3  i  gt  1   i --              assertTrue test getValue      i               test   test getNode                            Test     public void test reverseFourElement   throws Exception           Node node4   new Node 4  null           Node node3   new Node 3  node4           Node node2   new Node 2  node3           Node start   new Node 1  node2             start   reversalService reverse start           Node test   start          for  int i   4  i  gt  1   i --                assertTrue test getValue      i               test   test getNode                              Test         public void test reverse10Element   throws Exception               Node node10   new Node 10  null               Node node9   new Node 9  node10               Node node8   new Node 8  node9               Node node7   new Node 7  node8               Node node6   new Node 6  node7               Node node5   new Node 5  node6               Node node4   new Node 4  node5               Node node3   new Node 3  node4               Node node2   new Node 2  node3               Node start   new Node 1  node2                 start   reversalService reverse start               Node test   start              for  int i   10  i  gt  1   i --                    assertTrue test getValue      i                   test   test getNode                                Test     public void test reverseTwoElement   throws Exception           Node node2   new Node 2  null           Node start   new Node 1  node2             start   reversalService reverse start           Node test   start          for  int i   2  i  gt  1   i --                assertTrue test getValue      i               test   test getNode

User · Answer

Work out the time complexity of the algorithm you are using now and it should be obvious that it can not be improved

User · Answer

Solution using 1 variable  Only p    typedef unsigned long AddressType    define A     AddressType    amp p    define B     AddressType    amp first- gt link- gt link    define C     AddressType    amp first- gt link       Reversing linked list    p   first   while  first- gt link         A   A   B   C      B   A - B - C      A   A - B      C   A - C      A   A - C     first   p

User · Answer

Yes   I m sure you can do this the same way you can swap two numbers without using a third   Simply cast the pointers to a int long and perform the XOR operation a couple of times   This is one of those C tricks that makes for a fun question  but doesn t have any practical value     Can you reduce the O n  complexity   No  not really   Just use a doubly linked list if you think you are going to need the reverse order

User · Answer

How about the more readable    Node  pop  Node   root        Node  popped    root       if   root             root     root - next             return  popped      void push  Node   root  Node  new node        new node- next    root       root   new node      Node  reverse  Node  root        Node  new root   NULL      Node  next       while   next   pop  root              push   new root  next              return  new root

User · Answer

Just for fun  although tail recursion optimization should stop it eating all the stack     Node  reverse  Node  root  Node  end         Node  next   root- next      root- next   end       return  next   reverse next  root    root      root   reverse root  NULL

User · Answer

I hate to be the bearer of bad news but I don t think your three-pointer solution actually works  When I used it in the following test harness  the list was reduced to one node  as per the following output              4 3 2 1 0            4              You won t get better time complexity than your solution since it s O n  and you have to visit every node to change the pointers  but you can do a solution with only two extra pointers quite easily  as shown in the following code    include  lt stdio h gt      The list element type and head   struct node        int data      struct node  link     static struct node  first   NULL      A reverse function which uses only two extra pointers   void reverse            curNode traverses the list  first is reset to empty list      struct node  curNode   first   nxtNode      first   NULL          Until no more in list  insert current before first and advance      while  curNode    NULL               Need to save next node since we re changing the current          nxtNode   curNode- gt link              Insert at start of new list          curNode- gt link   first          first   curNode              Advance to next          curNode   nxtNode              Code to dump the current list   static void dumpNodes         struct node  curNode   first      printf              n        while  curNode    NULL            printf    d n   curNode- gt data           curNode   curNode- gt link              Test harness main program   int main  void        int i      struct node  newnode          Create list  using actually the same insert-before-first        that is used in reverse function       for  i   0  i  lt  5  i              newnode   malloc  sizeof  struct node            newnode- gt data   i          newnode- gt link   first          first   newnode                Dump list  reverse it  then dump again       dumpNodes        reverse        dumpNodes        printf              n         return 0      This code outputs              4 3 2 1 0            0 1 2 3 4              which I think is what you were after  It can actually do this since  once you ve loaded up first into the pointer traversing the list  you can re-use first at will

User · Answer

Here s a simpler version in python  It does use only two pointers slow  amp  fast def reverseList head  ListNode  - gt  ListNode       slow   None     fast   head     while fast            node next   fast next                  fast next   slow         slow   fast                      fast   node next     return slow

User · Answer

As an alternative  you can use recursion-  struct node  reverseList struct node  head        if head    NULL  return NULL      if head- gt next    NULL  return head       struct node  second   head- gt next             head- gt next   NULL       struct node  remaining   reverseList second       second- gt next   head       return remaining

User · Answer

include lt stdio h gt   include lt conio h gt   include lt stdlib h gt  struct node   int data  struct node  link     struct node  first NULL  last NULL  next  pre  cur  temp  void create     cur  struct node   malloc sizeof struct node    printf  enter first data to insert    scanf   d   amp cur- gt data   first last cur  first- gt link NULL    void insert     int pos c  cur  struct node   malloc sizeof struct node    printf  enter data to insert and also its position    scanf   d d   amp cur- gt data  amp pos   if pos  1    cur- gt link first  first cur    else   c 1      next first      while c lt pos                pre next          next next- gt link          c                  if pre  NULL                        printf  Invalid position                      else                   cur- gt link pre- gt link          pre- gt link cur                void display     cur first  while cur  NULL    printf  data   d t address   u n  cur- gt data cur   cur cur- gt link    printf   n      void rev     pre NULL  cur first  while cur  NULL    next cur- gt link  cur- gt link pre  pre cur  cur next    first pre    void main     int choice  clrscr    do   printf  Options are  - n1 Create n2 Insert n3 Display n4 Reverse n0 Exit n    printf  Enter your choice  -     scanf   d   amp choice   switch choice    case 1  create    break  case 2  insert    break  case 3  display    break  case 4  rev    break  case 0  exit 0   default  printf  wrong choice        while 1

User · Answer

class Node       Node next      int data       Node int item            data   item          next   null           public class LinkedList        static Node head         Print LinkedList     public static void printList Node node            while node  null               System out print node data                   node   node next                    System out println                 Reverse the LinkedList Utility     public static Node reverse Node node            Node new node   null           while node  null                Node next   node next              node next   new node              new node   node              node   next                     return new node             public static void main String   args               Creating LinkedList         LinkedList head   new Node 1           LinkedList head next   new Node 2           LinkedList head next next   new Node 3           LinkedList head next next next   new Node 4            LinkedList printList LinkedList head            Node node   LinkedList reverse LinkedList head            LinkedList printList node

[c] How to reverse a singly linked list using only two pointers?

Examples related to c

Examples related to algorithm

Examples related to data-structures

Examples related to linked-list

Examples related to singly-linked-list