Nsryjdtyk

I am beginning to understand recursion,

I have attached the recursion code to merge two sorted linked lists,

My problem is, I understand that 'temp' returns the value of temp->(first (or) second) once the first or second becomes null, but I am unable to understand the fact that,

Say for instance if I have 5 -> 10 -> 15 -> 20.

The final function returns 15 ->20 which is then combined as root.next-> temp, but after that step when I return temp, why does the root value gets returned.
i.e 10 -> 15 -> 20, when I expect only temp to be returned.

Please find the code,

 /**

 * 

 */

 *

 *

 */

public class MergeLinkedLists {



    static class Node {



        int data;

        Node next;



        public Node(int value) {

            this.data = value;

        }



    }



    Node root;



        /**

     * @param args

     */



    public static void main(String args) {

        // TODO Auto-generated method stub

        MergeLinkedLists s1 = new MergeLinkedLists();

        s1.root = new Node(0);

        Node n1 = new Node(10);

        //n1.next = new Node(20);

        //n1.next.next = new Node(30);



        Node n2 = new Node(5);

        n2.next = new Node(15);

        //n2.next.next = new Node(50);



        Node result = sortedLists(n1, n2, s1.root);



        while (result != null) {

            System.out.print(result.data + "--->");

            result = result.next;

        }

    }



    /**

     * @param n1

     * @param n2

      * @param root2

     */

     private static Node sortedLists(Node n1, Node n2, Node root) {

         // TODO Auto-generated method stub



        Node temp = root;



        Node first = n1; // 10 20 30

        Node second = n2; // 5 15 50



        if (first == null) {

            temp.next = second;

            return temp;

        } else if (second == null) {

            temp.next = first;

            return temp;

        }



        else if (first.data < second.data) {

            temp = new Node(first.data);

            first = first.next;

        } else {

            temp = new Node(second.data);

            second = second.next;

        }



        sortedLists(first, second, temp);

        root.next = temp;

        System.out.println("The Temp Data is ::::"+temp.data);

        return temp;



    }



}

Because temp is in this case the root value. Don't worry, this is the one thing you need to understand in order to understand recursion itself.

A great feature to understand the functionality of your code is to use the debugger. Set a breakpoint to the function call and you can step through the program, while you can observe how the variables change.

This aside, let's have a look at your code.

Important to note is that whenever you call your sortedLists(first, second, temp); the pointer will get into it until the function terminates (so when it returns temp). You will call this function multiple times as the program continues, so it will get deeper into its own function.
It then carries the information step-by-step on level up until the first call of sortedLists(first, second, temp); terminates and this is in your main method Node result = sortedLists(n1, n2, s1.root);

I will try to get along with your example:

1. Node result = sortedLists(n1, n2, s1.root);called in the main()method. So the root is 0 and you have your nodes 10 and 5,15.




2. In the first call of sortedLists() temp becomes 5 and second now carries a 15, because first.data > second.data.



3. 
   

   NOW You call the method sortedLists()again but with new values: the root is now 5, first remains 10 and second is 15. We step inside the function and start with the new values:

   
   
   
   
   
   1. because of first.data < second.data, temp becomes 10, first is now null.
   
   
   2. and again: we reached another call on sortedLists(). We pass the values: first = null second = 15 root = 10 to the function and go one step deeper.
      
      
      
      
      1. as first is now zero, temp.next will be second(15)
      
      
      2. temp looks like this now: 10->15 and we return. (this is the first time, sortedLists() terminates!)
      
      
      
      
   
   
   3. We are now back here and can move on with root.next = temp; Remember what temp was in this context? temp was 10 but it has been updated by the function above. The new temp is 10->15, so our root looks like: 5->10->15.
   
   
   4. Then you print the head of temp, which is 10. This function also terminates.
   
   
   
   



4. now we are back in our first call and see what happens: in 3.3 we updated the root of it. The root of 3.3 was the temp of 3 because we called sortedLists(first, second, temp) (temp acts as the root because the last argument of this function is Node root).




5. To sum up: Our root is still 0 and our temp is 5->10->15




6. root.next is after this assignment 0->5->10->15. Now the root you declared in your class above the main method has a value.




7. we return the temp which is 5->10->15 and we are done.

We now can proceed in the main method, printing the results.

To get rid of the ---> when there is no result.next, you can handle the null value like this:

 while (result != null) {

            if (result.next != null)

            System.out.print(result.data + "--->");

            else System.out.println(result.data);

            result = result.next;

        }

I hope this helps a bit to get into recursion.