到达目的地的最少步骤数？

Question

I am learning data Structures from few days.Suppose, we have a Data structure that is built from layer of nodes. All layers start with 'start' node and end with a null value instead of last node. Each node has a 'value', 'foll' pointer to next node and 'down' pointer to the next node in the same layer. On each layer, values are sorted in ascending order.

Example:

1. S ---- 9 -------------------------------------->NULL

     | 

2. S -----9---------27---------51-------------->NULL

     | | | 

3. S -----9---23---27--29---51----53------->NULL

Data Structure for Node:

   `      Class Node {
                  int value;
                   Node foll;
                      Node down;
                  }                 `

Write a function findNode that will get a starting node head and a search value value and will return the minimum number of jumps that are needed in order to either reach node with that value or to determine that it does not exist in the data structure.

Input : Number of layers, followed by a list of new nodes for each layer and finally the number that should be found. All of the values are integers larger than zero.

4

7

27 51

24 80

4 32 54 69 82

54

will result in data structure described above and value to be found is 54

Output

7

Can anyone please tell me, what should be following function in Java?

static int findNode(Node start, int value) { }

Answer 1

The easiest way to approach this problem would be with a recursive solution. Think about this problem as starting at one node, and then expanding in every direction possible until it reaches the node it's looking for.

The first thing you need in any recursive function is a base case, or what to do when it can't go any further. In our case, if we reach the end without finding the node we want, we could break, or return 1 if we find the node we want.

The next part is the recursive call. So if we have not found what we want and we have more places to go, then we can keep go to the surrounding nodes and adding 1 to our depth with every call.

In code, this would be something similar to this:

static int findNode(Node start, int value){
    if(start.value == value)
        return 1;
    else if(Node == null)
        break;

    return Math.min(findNode(start.foll) + 1, findNode(start.down) + 1);
}

You might have to change this a little bit and exchange break with another way of stopping, but hopefully this give you the idea.