Data-structures-and-algorithms | Java data structure and sorting algorithm | Learning library

The difference in numbers that you see in the recursion trace comes from n/2 in the code. It is an integer division by two. So 13/2 is 6 and 6/2 is 3 and 3/2 is 1, and finally 1/2 is 0. This is what you see when you read the diagram from top to bottom. The diagram shows these entries shifted more and more to the right to represent the depth of the recursion. The function calls itself, and then it calls itself again, ...etc. All of these calls are pending... Each time these calls pass a value for n that is smaller (halved).

Somewhere this stops. It needs to, of course. This stops when the value of n receives the value 0. You see this state at the bottom of the diagram. At that moment, the recursion does not go deeper and starts to unwind, and you need to read the diagram now from bottom back to the top. For n equal to 0, the return value is 1 (return 1).

This value is read by the function execution where n is 1 and where the call power(2, 0) was made and waiting for a return value. It receives 1 as result. This value is then squared (partial * partial) which in this case still is 1. And because n is odd (it is 1 here), there is an additional multiplication *= x. So we actually calculate partial * partial * x, which is 1 * 1 * 2. You'll see this in the diagram.

And this value (2) is returned to the function execution where n is 3 and where the call power(2, 1) was made. It receives 2 as result. This value is then squared (partial * partial) which in this case is 4. And because n is odd (it is 3 here), there is an additional multiplication *= x. So we actually calculate partial * partial * x, which is 2 * 2 * 2. You'll see this in the diagram.

I hope you see the pattern. The function executions that are pending for a result, all get their value back from the recursive function call they made, do some multiplication with it and return that, in turn, to their caller.

And so the recursion backtracks to the top, providing the end result to the top-level call of power(2, 13).

The top one defines j once per outer loop. 10.000 times. In the bottom one you have to decrease j in every inner loop control for testing. That's (10.000 * 10.000 - 10.000)/2 as an upper limit (thanks to @trincot for correcting this) operations more.

Slower Version:

As stated in comments, JavaScript has native support for deque operations via its Array class/prototype: push, pop, shift, unshift.

If you still want to write your own implementation, then you can go for a doubly linked list, where you just need two "pointers". It should be said that in JavaScript we don't really speak of pointers, but of objects. Variables or properties that get an object as value, are in fact references in JavaScript.

Alternatively, you can go for a circular array. Since in JavaScript standard Arrays are not guaranteed to be consecutive arrays as for example is the case in C, you don't really need to use an Array instance for that. A plain object (or Map) will do.

So here are two possible implementations:

Here's a way to implement your algorithm without recursion (not that I actually think there's anything inherently wrong with recursion).

In your case before making these recursive calls the position = 1. And you can imagine your stack as:

Main()->FindPath()

Imagine that in order to find exit the program made 3 recursive calls. Then the stack is:

Main()->FindPath()->FindPath()->FindPath()->FindPath()

At this point the position = 4.

After printing the result, method calls return, but before that they decrease the position by 1.

So before going for another set of recursive calls your stack is again looks like this:

Main()->FindPath()

and the position = 1.