Question

I’m doing a project in Java which includes (x,y) coordinates.
I have created a class of Cell which has protected integers X & Y;
Upon initialization, i do a for loop which sets an array of cell by multiplying the X & Y given by the user, say if X= 10 and Y = 10, i create an array of cells[100].

However, how can i search the array fast, without doing a for loop and checking each individual value very time?

Say I’m looking for the object that contains X=5 & y = 3.
I know i can go through with a for loop looking for object with values x and y, but i was wondering if there is a way to do a binary search and find “a bit faster” the object[i] that contains X=5 and Y=5.

Thank you very much.

Answer 1

The way to do this is to arrange the Cell objects in the array in a way so that there is a simple mapping from an X,Y coordinate to the Cell’s index in the array.

For example, lets assume that X and Y go from 1 to 10. Suppose that we then arrange the Cells so that:

array[0] = Cell(1, 1);
array[1] = Cell(1, 2);
...
array[9] = Cell(1, 10);
array[10] = Cell(2, 1);
array[11] = Cell(2, 2);
...
array[99] = Cell(10, 10);

It should be easy to see that we can calculate the index of Cell(i,j) in the array and fetch the cell as follows:

public Cell getCell(Cell[] array, int i, int j) {
    int index = (10 * (i - 1)) + (j - 1);
    return array[index];
}

This is the approach that programming languages that support N-dimensional array types typically use to implement them.

This can be trivially modified to deal with cases where:

• the constant 10 is something else
• the matrix is not square,
• the matrix has more than two dimensions
• indexes run from 0 to N – 1 instead of 1 to N
• etcetera

There are various other ways that you could represent 2-D matrices in Java. The simplest one is just using a Cell[][] cells which allows you to access cells as (for example) cells[i-1][j-1]. More complicated representations can be designed that use less space if the matrix is sparse (i.e. cells are missing) at the cost of more complex code and slower access times.