Question

I’ve been asked recently to implement two classes that represent Point2D points and Point3D points. The distance and the other methods work fine, yet there’s only one left that needs to be implemented and I can’t figure out the algorithm. It’s stated like this:

“Given a set of points in space, determine that point from the set that is the closest to another point in space (that’s not in the set)”

Below are the two classes. Can anybody help me with the last needed algorithm?

    public class Point2D {
    protected double x;
    protected double y;

    public Point2D() { }

    public Point2D(double x, double y)
    {
        this.x = x;
        this.y = y;
    }

    public double getX() { return x; }
    public void setX(double x) { this.x = x; }
    public double getY() { return y; }
    public void setY(double y) { this.y = y; }

    public double Point2DDistance(Point2D punct)
    {
        double px = this.x - punct.x;
        double py = this.y - punct.y;

        return Math.sqrt((px * px) + (py * py));
    }

    public String toString() {
        return "(" + x + ", " + y + ")";
    } 
}

public class Point3D extends Point2D {
    private double z;

    public Point3D() { }

    public Point3D(double x, double y, double z)
    {
        super(x, y);
        this.z = z;
    }

    public double getZ() { return z; }
    public void setZ(double z) { this.z = z; }

    public double Point3DDistance(Point3D punct)
    {
        double pz = this.z - punct.z;

        return this.Point2DDistance(punct) + Math.sqrt(pz * pz);
    }

    public String toString() {
        return "(" + this.x + ", " + this.y + ", " + this.z + ")";
    }
}

Answer 1

Iterate through the points.

For each point,

• if this is the first point, set min_distance = the point’s distance to the not-in-set point P, and copy this point to closestP, and

• otherwise, if this point’s distance to P is less than min_distance, set min_distance to this point’s distance, and copy this point to closestP.

Now closestP holds the closest point, and min_distance holds the distance it has from P.

Hurray!