That conditional is a bit ugly, why not

if(head == null) return;
ReversePrint(head.next);
System.out.println(head.data);

// OR

if (head != null) {
   ReversePrint(head.next);
   System.out.println(head.data); 
}

So true :)

So true. :D

void ReversePrint(Node *head) { // This is a "method-only" submission. // You only need to complete this method. if(head){ ReversePrint(head->next); printf("%d\n",head->data); } }

My only conern with this is that a LinkedList could be quite long, and the recursion depth limit is usually only around 5000, which really isn't that deep.

I took sophist_pt's code and altered it a bit to hopefully make it more intuitive.

void ReversePrint(Node head) {

    //if the head is not yet null...
    if (head != null) {
        //call the function again but on the next node
        ReversePrint(head.next);
        /*----------------------------------------------
        The recursion will get "stacked" right here!
        The code below this area will not get called
        until we go back up through the recursive stack.
        -----------------------------------------------*/
        System.out.println(head.data);
    }
}

Here's a code trace for an example. We have a linked list of three elements [1] -> [2] -> [3] Let's begin by calling the head.

A. RevPr(1)
if elemenent 1 is not yet null, move on.
It's not null! Call again on next, element 2...
    B. RevPr(2)
    if elemenent 2 is not yet null, move on.
    It's not null! Call again on next, element
    3...
        C.  RevPr(3)
        if elemenent 3 is not yet null,
        move on. It's not null! Call again
        on next, element 4...
            D. RevPr(4)
            if elemenent 4 is not yet null, move on. 
            Wait, it is null! No more calls, we're done.

So we just built this recursive stack. [RevPr1(RevPr2(RevPr3(RevPr4)))] Now we have to execute the function that is innermost. Why? Because that's where we were most recently!

            D. RevPr4. That most recent call failed the
            condition. Nothing is printed.
            -->[RevPr1(RevPr2(RevPr3()))]
        C. RevPr3. RevPr3 never finished the code in
        the if statement, so now we print 3!
        -->3
        -->[RevPr1(RevPr2())]
    B. RevPr2. Now we need to print 2!
    -->3
    -->2
    -->[RevPr1()]
A. RevPr1. The last call! Print 1! This call is done, and
now everything is done.
-->3
-->2
-->1

This function was written from sophist_pt's brilliant code.

fantastic!

void ReversePrint(Node *head) { // This is a "method-only" submission. // You only need to complete this method. if(head){ ReversePrint(head->next); printf("%d\n",head->data); } }

Have you figured it out? Can you post your code? Both versions of the solution above work.

Hi,

I got this runtime exception as well. For me, it was for the Test Case #1 where they have an input of just 0 for one of there queries. Normally, it is a number for the # of nodes in the linked list followed by a set of numbers that need to be reversely printed.

You can test it out by using custom input of the Test Case #1 input and removing the 0 from the input data and changing the first 5 to 4 queries after.

It can and will

Yeah. Recursive solutions generally don't work well when n is very big because of the demands on the stack. Classic example is computing the Fibonacci numbers. Compare the recurisve solution against the iterative one.

Yes, I agree and this can be an important consideration for large data sets or relatively large data sets on platforms with restricted stack sizes. If Hackerrank doesn't already, I think they could include variations on problems like this that enforce iterative solutions.

This immediately came to mind for me. It might look really nice, and really neat, but you would never do this in reality. You run the risk of overflowing the stack.

Hi , How this code will display reverse data?

how it works??

-

really...its a wonderful thought

same here in C#:

**

public static void ReversePrint(Node head) {
   if (head != null) {
     var tempNode = head;
     var counter = 1;
     while (tempNode.Next != null) {
       ++counter;
       tempNode = tempNode.Next;
     }
     int[] arr = new int[counter];

     counter = 1;
     tempNode = head;
     while (tempNode.Next != null) {
       arr[counter - 1] = tempNode.Data;
       ++counter;
       tempNode = tempNode.Next;
     }
     arr[counter-1] = tempNode.Data;
     for (int i = arr.Length - 1; i >= 0; --i) {
       Console.WriteLine(arr[i]);
     }
   }

 }

**

Using ArrayList :

static void reversePrint(SinglyLinkedListNode head) { SinglyLinkedListNode temp; ArrayList cars = new ArrayList(); temp = head; while(temp!=null) { cars.add(temp.data); temp = temp.next; } for(int i = cars.size()-1; i>=0; i--) { System.out.println(cars.get(i)); } }

Because you are first putting it as head.next which means if it IS null, it will already be at head.next and the return will basically return to the pre-recursion of the last function just to get print a null value

What his code does is, if head.next is null, it will return so that head.data will be printed, otherwise, head=head.next will happen and that will be put into the same function

Can you plz explain how recursion works here

no I declared that