在Java中访问深度嵌套的对象Box

Question

Let's say you have a box that could contain a maximum of 50 objects. Weirdly, the box could also contain another box (which could also contain a maximum of 50 objects), and that this "nested" box does not occupy any space in the outer box.

The "nested" box could also contain another box, and so on... ad infinitum.

Thus, I wrote a service class Box as follows:

class Box {

  private Box nestedBox;

  public Box getBox() {
    return nestedBox;
  }

  //other code
}

The user is allowed to create as many boxes as he likes. But each box he creates will be nested inside the "deepest" box.

So, for example, if he wishes to create three boxes: the first box will be created first, then the second box will be created inside the first box, then finally, the third and last box will be created inside the second box.

How do I go about writing a program that does this creation? I was told to use something like recursion .

Here is my attempt:

public static void main(String[] args) {

  int numOfBoxes;
  Scanner sc = new Scanner(System.in);

  numOfBoxes = sc.nextInt();

  if (numOfBoxes == 1) {
    Box b = new Box();
  } else {
    Box b = new Box();
    for (int i = 1; i < numOfBoxes; i++) {
      b.getBox() = new Box();
    }
  }

}

I really appreciate it if someone could help me with this. Feel free to change the class Box and the main method. I was told to use recursion, but I couldn't figure this out.

Answer 1

As you've described it (with each box containing a max of 1 box) what you have is effectively a linked list. You don't need recursion for that, just walk the list keeping the current box in a variable.

But possibly what you're trying to solve for (where a box can contain multiple boxes) is a tree, and what you need is a search function for that tree. Without knowing anything of the expected node distribution in your tree, I would highly recommend doing a DFS ( https://en.wikipedia.org/wiki/Depth-first_search ), as this is easy to implement and is performant on a broad array of tree types.

Answer 2

One way is to hold a reference to the most out box.

class Box{
    private Box nestedBox;
    public Box(){

    }
    public Box(Box nestedBox){
        this.nestedBox = nestedBox;
    }
}
public class Main {
    public static void main(String[] args) {
        int numOfBoxes = 4;
        Box nestedBox = null;
        for(int i = 0; i < numOfBoxes; i++){
            nestedBox = new Box(nestedBox);
        }
    }
}

Answer 3

Alternatively, if you really require building the boxes w/ a recursive solution, you can do it within the constructor. Example:

import java.util.Scanner;

class Box{

    private Box nestedBox;

    public Box(int numOfInnerBoxes){
        if (numOfInnerBoxes > 0) {
            this.nestedBox = new Box(numOfInnerBoxes - 1);
        }
        System.out.println("This box "+ this +" contains box "+ this.nestedBox +".");
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int numOfBoxes = sc.nextInt();
        Box outerBox = new Box(numOfBoxes-1);
        System.out.println("The outermost box is "+ outerBox +".");
    }

}

Example output:

$ java Box
4
This box Box@55f96302 contains box null.
This box Box@3d4eac69 contains box Box@55f96302.
This box Box@42a57993 contains box Box@3d4eac69.
This box Box@75b84c92 contains box Box@42a57993.
The outermost box is Box@75b84c92.

Note that every constructor decrements the number of inner boxes to create until zero is reached. This is the essence of a recursive solution.