Question

For example I make the recursive call defined below. The method finds the kth element from the last. If found, it assigns the current node to the object I pass to the recursive call. For some reason the node kth is null. Can you not do things this way? And why?

public void findKthFromLast(Node head, int k){
    Node kth;     
    recrusiveHelper(head, k, kth);
    System.out.println(kth.data); //this is null
}

public int recursiveHelper(Node n, int k, Node kthFromLast){
    (if n == null){
        return 0;
    }
    val = 1 + recursiveHelper(n.next, k, kthFromlast);
    if(k == val){
        kthFromLast = n;
    }
    return val;
}

Answer 1

Firstly, that code shouldn’t compile because kth is not initialized and so cannot be used as argument for the recursiveHelper method call.

Secondly, any changes to the references in a called method are not propagated to the caller in Java, i.e.

private void caller()
{
    StringBuilder s = new StringBuilder();
    s.append("test");
    calledMethod1(s);
    System.out.println(s.toString());
    calledMethod2(s);
    System.out.println(s.toString());
}

private void calledMethod1(StringBuilder buffer)
{
    buffer = new StringBuilder();
    buffer.append("calledMethod1");
    return;
}

private void calledMethod2(StringBuilder buffer)
{
    buffer.append(", calledMethod2");
    return;
}

Output:

test
test, calledMethod2

The reason is, in calledMethod1 you are merely changing what buffer reference points to but not making any changes to what buffer reference was pointing when the method was called. In calledMethod2, you are making changes to the object referred by buffer and hence the changes are visible in the caller.

If you are someone coming from C or C++ background, this is equivalent to assigning to a pointer argument in a called method which doesn’t affect what was passed in the caller.