Was ist der Schnellste Weg, um finden Sie den nächsten Punkt zu einem gegebenen Punkt?

Können Sie organisieren Sie Ihre Punkte in eine Octree. Dann brauchen Sie nur zu suchen, eine kleine Teilmenge.

Ein Octree ist eine Recht einfache Datenstruktur, die Sie implementieren können, sich selbst (das wäre eine wertvolle Erfahrung), oder Sie finden möglicherweise einige nützliche Bibliotheken, um Sie gehen.

Schlage ich vor KD-Baum wird gut funktionieren. Auch gut für die nächste Nachbar Suche.

Ich mit einem KD-Baum zu tun, dies in O(log(n)) Zeit, vorausgesetzt, die Punkte sind zufällig verteilt, oder Sie haben einen Weg, um den Baum balanciert.

http://en.wikipedia.org/wiki/Kd-tree

KD-Bäume eignen sich hervorragend für diese Art der räumlichen Abfrage, und erlaubt auch das abrufen der nächsten k Nachbarn zu einem Abfrage-Punkt.

Ich musste das tun, etwas zu stark für die viele nächste-Nachbarn-Suche in einer Echtzeit-Umgebung, und treffen auf einen besseren Algorithmus sowohl in Bezug auf Einfachheit und Geschwindigkeit.

Nehmen Sie alle Ihre Punkte und legen Sie eine Kopie in d Listen, wobei d die Dimensionalität des Raumes. In Ihrem 3. Fall. Sortieren Sie diese drei Listen, die nach Ihrer dimension. Diese Kosten d(nlog(n)) Zeit. Und, dass es für die Datenstruktur.

Wir pflegen Sie diese richtig sortiert Listen in jeder dimension für alle Punkte in Frage. Der trick ist, dass durch die definition der Abstand in einer Richtung muss kleiner als oder gleich dem euklidischen Abstand. Also, wenn der Abstand in einer Richtung größer ist als unsere derzeitige nächsten Abstand von den nächsten bekannten Punkt, dann diesen Punkt nicht näher, und noch wichtiger, alle Punkte in diese Richtung nicht größer sein. Einmal gilt das für die 2*d-Richtungen, die wir haben, die wir per definition haben den nächsten Punkt.

Für jedes einzelne element können wir binarysearch-Methode in die sortierte Listen zu finden der nächsten position, wo der gewünschte Punkt konnte in den zwei verschiedenen Dimensionen. Mathematisch wir wissen, dass, wenn der Abstand in der +x -x +y -y (andere Abmessungen sind einfach zu addieren) Richtungen überschreitet kleinste bekannte euklidische Distanz zu einem Punkt, dass diesem Punkt muss größer sein als der Abstand, und da es ein sortiertes array, per definition, wenn wir Sie überschreiten, der Abstand in diese Richtung, wir wissen, dass wir Abbrechen können, die Richtung, da kann es keine bessere Antwort in dieser Richtung. Aber, wie wir erweitern in diese vier Richtungen können wir reduzieren unsere Wert von m, da ist es gleich der euklidische Abstand des nächsten Punktes, die wir gefunden.

Damit wir nur müssen sortierte Listen für jede Achse sortiert nach, dass die Achse. Das ist ziemlich einfach.

Dann zum Abfragen der Liste:

• Wir binäre Suche in den einzelnen Listen (dlog(n)).
• Wir finden unsere aktuellen minimalen Abstand m. (anfangs kann es sein, unendlich)
• Für jede Liste, die wir Reisen in den positiven und negativen Richtungen.
• Für jede der 2*d-Richtungen, die wir haben,
  • Wir quer die Listen, Senkung m, wenn wir näher Punkte.
• Wenn die Richtung erweist sich als mathematisch ergebnislos ist, dass wir aufhören zu suchen, dass Art und Weise.
• Wenn keine Richtung bleibt, die wir gefunden haben, zu unserem nächsten Punkt.

Wir haben sortierte Listen und müssen um den Punkt zu finden, die wir suchen, in jede Richtung, in die Liste. Wir binäre Suche, um unsere Zeit-Komplexität von log(n). Dann haben wir unsere aktuell besten Entfernung (möglicherweise unendlich) und dann bewegen wir uns in jede Richtung, die uns zur Verfügung stehen. Wie finden wir neue Punkte, aktualisieren wir den nächsten Punkt, so weit wir haben. Der trick ist, dass wir aufhören, sobald der Abstand in der jeweiligen Richtung ist weiter als unsere aktuelle bekannte nächsten Punkt.

Wenn wir also einen Punkt, bei einer bekannten am nächsten Abstand von 13 dann können wir Abbrechen Check-in die +x, -x, +y, -y, - Richtungen, sobald die Distanz in nur eine Richtung, überschreitet unsere nächsten bekannten Entfernung. Denn wenn es weiter in +x als unsere jetzige m, alle übrigen Werte von +x kann mathematisch bewiesen werden, weiter entfernt. Wie wir besser und besser nächsten Punkte, die Menge der Raum, den wir suchen müssen, wird kleiner und kleiner.

Wenn wir die Punkte in eine Richtung, die Richtung ist fertig.
Wenn der Abstand zu einem Punkt zusammen, nur dass eine dimension der Linie selbst ist größer als m, die Richtung ist fertig.

Die Lösung ist m in alle Richtungen nachgewiesen zu haben nur Punkte sein müssen, weiter als unsere beste Punkt so weit.

-- Da wir nach und nach reduzieren m, der Abstand in jeder dimension als ganzes, fällt schnell auf, das aber wie alle algorithmen, es fällt weniger schnell in höhere Dimensionen. Aber, wenn die Distanz in nur einer dimension größer ist als die besten, die wir bisher haben, muss es zwangsläufig der Fall sein, dass der ganze rest der Punkte in dieser Richtung, kann nicht besser sein.

In der Zeit Komplexität scheint auf Augenhöhe mit dem besseren. Aber in der Einfachheit der Datenstrukturen, ist dieser Algorithmus deutlich gewinnt. Es gibt eine Menge anderer Eigenschaften, die diesem Algorithmus zu einem ernsthaften Anwärter. Wenn Sie ein update von Sachen, können Sie resort die Listen mit wirklich guter Leistung, weil Sie sehr oft Sortieren bereits sortierte Listen oder fast sortierten Listen. Sie sind arrays zu iterieren. In der tatsächlichen realen Leistung die meisten Datenstrukturen saugen. In der Regel, weil der Zwischenspeicherung und wie Speicher ist gelegt, wir sollen nicht wissen über solche Dinge, aber es eine Menge Fragen. Die Daten rechts neben dem aktuellen relevanten Daten viel schneller zu den tatsächlichen Zugriff. Wenn wir schon wissen, wo der Punkt, den wir gehen, um suchen es in der Liste, die wir lösen können es sogar schneller (da würden wir nicht haben, um es zu finden mit einem binäre Suche). Und andere tricks erlaubt die Wiederverwendung der Informationen aus der vorherigen iteration hier und da. Und die zusätzlichen Dimensionen sind grundsätzlich kostenlos (außer dass dann der Wert nicht konvergieren schneller, aber das ist, weil es mehr zufällig verteilte Punkte in einem Bereich als einen Kreis mit dem gleichen radius).

public class EuclideanNeighborSearch2D {
    public static final int INVALID = -1;
    static final Comparator<Point> xsort = new Comparator<Point>() {
        @Override
        public int compare(Point o1, Point o2) {
            return Double.compare(o1.x, o2.x);
        }
    };
    static final Comparator<Point> ysort = new Comparator<Point>() {
        @Override
        public int compare(Point o1, Point o2) {
            return Double.compare(o1.y, o2.y);
        }
    };

    ArrayList<Point> xaxis = new ArrayList<>();
    ArrayList<Point> yaxis = new ArrayList<>();

    boolean dirtySortX = false;
    boolean dirtySortY = false;

    public Point findNearest(float x, float y, float minDistance, float maxDistance) {
        Point find = new Point(x,y);

        sortXAxisList();
        sortYAxisList();

        double findingDistanceMaxSq = maxDistance * maxDistance;
        double findingDistanceMinSq = minDistance * minDistance;

        Point findingIndex = null;

        int posx = Collections.binarySearch(xaxis, find, xsort);
        int posy = Collections.binarySearch(yaxis, find, ysort);
        if (posx < 0) posx = ~posx;
        if (posy < 0) posy = ~posy;

        int mask = 0b1111;

        Point v;

        double vx, vy;
        int o;
        int itr = 0;
        while (mask != 0) {
            if ((mask & (1 << (itr & 3))) == 0) {
                itr++;
                continue; //if that direction is no longer used.
            }
            switch (itr & 3) {
                default:
                case 0: //+x
                    o = posx + (itr++ >> 2);
                    if (o >= xaxis.size()) {
                        mask &= 0b1110;
                        continue;
                    }
                    v = xaxis.get(o);
                    vx = x - v.x;
                    vy = y - v.y;
                    vx *= vx;
                    vy *= vy;
                    if (vx > findingDistanceMaxSq) {
                        mask &= 0b1110;
                        continue;
                    }
                    break;
                case 1: //+y
                    o = posy + (itr++ >> 2);
                    if (o >= yaxis.size()) {
                        mask &= 0b1101;
                        continue;
                    }
                    v = yaxis.get(o);
                    vx = x - v.x;
                    vy = y - v.y;
                    vx *= vx;
                    vy *= vy;
                    if (vy > findingDistanceMaxSq) {
                        mask &= 0b1101;
                        continue;
                    }
                    break;
                case 2: //-x
                    o = posx + ~(itr++ >> 2);
                    if (o < 0) {
                        mask &= 0b1011;
                        continue;
                    }
                    v = xaxis.get(o);
                    vx = x - v.x;
                    vy = y - v.y;
                    vx *= vx;
                    vy *= vy;
                    if (vx > findingDistanceMaxSq) {
                        mask &= 0b1011;
                        continue;
                    }
                    break;
                case 3: //-y
                    o = posy + ~(itr++ >> 2);
                    if (o < 0) {
                        mask = mask & 0b0111;
                        continue;
                    }
                    v = yaxis.get(o);
                    vx = x - v.x;
                    vy = y - v.y;
                    vx *= vx;
                    vy *= vy;
                    if (vy > findingDistanceMaxSq) {
                        mask = mask & 0b0111;
                        continue;
                    }
                    break;
            }
            double d = vx + vy;

            if (d <= findingDistanceMinSq) continue;

            if (d < findingDistanceMaxSq) {
                findingDistanceMaxSq = d;
                findingIndex = v;
            }

        }
        return findingIndex;
    }

    private void sortXAxisList() {
        if (!dirtySortX) return;
        Collections.sort(xaxis, xsort);
        dirtySortX = false;
    }

    private void sortYAxisList() {
        if (!dirtySortY) return;
        Collections.sort(yaxis,ysort);
        dirtySortY = false;
    }

    /**
     * Called if something should have invalidated the points for some reason.
     * Such as being moved outside of this class or otherwise updated.
     */
    public void update() {
        dirtySortX = true;
        dirtySortY = true;
    }

    /**
     * Called to add a point to the sorted list without needing to resort the list.
     * @param p Point to add.
     */
    public final void add(Point p) {
        sortXAxisList();
        sortYAxisList();
        int posx = Collections.binarySearch(xaxis, p, xsort);
        int posy = Collections.binarySearch(yaxis, p, ysort);
        if (posx < 0) posx = ~posx;
        if (posy < 0) posy = ~posy;
        xaxis.add(posx, p);
        yaxis.add(posy, p);
    }

    /**
     * Called to remove a point to the sorted list without needing to resort the list.
     * @param p Point to add.
     */
    public final void remove(Point p) {
        sortXAxisList();
        sortYAxisList();
        int posx = Collections.binarySearch(xaxis, p, xsort);
        int posy = Collections.binarySearch(yaxis, p, ysort);
        if (posx < 0) posx = ~posx;
        if (posy < 0) posy = ~posy;
        xaxis.remove(posx);
        yaxis.remove(posy);
    }
}

Update: Mit Rücksicht auf, in den Kommentaren, die k-Punkte problem. Sie werden feststellen, dass sehr wenig geändert. Das einzig relevante an der Sache war, wenn der Punkt v ist, gefunden werden, werden weniger als die aktuelle m (findingDistanceMaxSq), dann wird dieser Punkt Hinzugefügt wird, um den heap, und der Wert für m ist gleich der euklidischen Distanz zwischen der Feststellung der position und der kth element. Die reguläre version des Algorithmus gesehen werden kann, wie in dem Fall, wo k = 1. Wir suchen für die 1-element, das wir wollen und aktualisieren Sie m, um gleich die einzige (k=1) element beim v ist gefunden zu werden, näher.

Bedenkt, dass ich immer nur Abstand comparatives in der Ferne squared form, da ich nur jemals müssen wissen, wenn es weiter Weg, und ich don ' T waste clock-Zyklen auf Quadratwurzel-Funktionen.

Und ich weiß, es ist eine perfekte Datenstruktur für die Speicherung der k-Elemente in einer Größe begrenzte heap. Offensichtlich ein array einfügen ist nicht optimal dafür. Aber, andere als zu viel java-abhängige apis, die es einfach nicht für die jeweilige Klasse, aber anscheinend ist Google Guava macht. Aber Sie nicht wirklich bemerken an alle gegeben, die Chancen stehen gut, dass Ihr k ist wahrscheinlich nicht so groß. Aber, es macht die Zeit-Komplexität für eine insertion in Punkte gespeichert in k-Zeit. Es gibt auch Dinge wie caching die Entfernung von der Suche für die Elemente.

Schließlich, und wahrscheinlich die meisten pressingly, das Projekt, das ich verwenden würde, um den code zu testen, ist im übergang, so habe ich es nicht geschafft, dieses heraus zu testen. Aber, es ist sicherlich zeigt, wie Sie dies tun: Sie speichern die k besten Ergebnisse bisher, und machen m gleich dem Abstand der der kth nächsten Punkt. -- Alles andere bleibt gleich.

Beispiel Quelle.

public static double distanceSq(double x0, double y0, double x1, double y1) {
    double dx = x1 - x0;
    double dy = y1 - y0;
    dx *= dx;
    dy *= dy;
    return dx + dy;
}
public Collection<Point> findNearest(int k, final float x, final float y, float minDistance, float maxDistance) {
    sortXAxisList();
    sortYAxisList();

    double findingDistanceMaxSq = maxDistance * maxDistance;
    double findingDistanceMinSq = minDistance * minDistance;
    ArrayList<Point> kpointsShouldBeHeap = new ArrayList<>(k);
    Comparator<Point> euclideanCompare = new Comparator<Point>() {
        @Override
        public int compare(Point o1, Point o2) {
            return Double.compare(distanceSq(x, y, o1.x, o1.y), distanceSq(x, y, o2.x, o2.y));
        }
    };

    Point find = new Point(x, y);
    int posx = Collections.binarySearch(xaxis, find, xsort);
    int posy = Collections.binarySearch(yaxis, find, ysort);
    if (posx < 0) posx = ~posx;
    if (posy < 0) posy = ~posy;

    int mask = 0b1111;

    Point v;

    double vx, vy;
    int o;
    int itr = 0;
    while (mask != 0) {
        if ((mask & (1 << (itr & 3))) == 0) {
            itr++;
            continue; //if that direction is no longer used.
        }
        switch (itr & 3) {
            default:
            case 0: //+x
                o = posx + (itr++ >> 2);
                if (o >= xaxis.size()) {
                    mask &= 0b1110;
                    continue;
                }
                v = xaxis.get(o);
                vx = x - v.x;
                vy = y - v.y;
                vx *= vx;
                vy *= vy;
                if (vx > findingDistanceMaxSq) {
                    mask &= 0b1110;
                    continue;
                }
                break;
            case 1: //+y
                o = posy + (itr++ >> 2);
                if (o >= yaxis.size()) {
                    mask &= 0b1101;
                    continue;
                }
                v = yaxis.get(o);
                vx = x - v.x;
                vy = y - v.y;
                vx *= vx;
                vy *= vy;
                if (vy > findingDistanceMaxSq) {
                    mask &= 0b1101;
                    continue;
                }
                break;
            case 2: //-x
                o = posx + ~(itr++ >> 2);
                if (o < 0) {
                    mask &= 0b1011;
                    continue;
                }
                v = xaxis.get(o);
                vx = x - v.x;
                vy = y - v.y;
                vx *= vx;
                vy *= vy;
                if (vx > findingDistanceMaxSq) {
                    mask &= 0b1011;
                    continue;
                }
                break;
            case 3: //-y
                o = posy + ~(itr++ >> 2);
                if (o < 0) {
                    mask = mask & 0b0111;
                    continue;
                }
                v = yaxis.get(o);
                vx = x - v.x;
                vy = y - v.y;
                vx *= vx;
                vy *= vy;
                if (vy > findingDistanceMaxSq) {
                    mask = mask & 0b0111;
                    continue;
                }
                break;
        }
        double d = vx + vy;
        if (d <= findingDistanceMinSq) continue;
        if (d < findingDistanceMaxSq) {
            int insert = Collections.binarySearch(kpointsShouldBeHeap, v, euclideanCompare);
            if (insert < 0) insert = ~insert;
            kpointsShouldBeHeap.add(insert, v);
            if (k < kpointsShouldBeHeap.size()) {
                Point kthPoint = kpointsShouldBeHeap.get(k);
                findingDistanceMaxSq = distanceSq(x, y, kthPoint.x, kthPoint.y);
            }
        }
    }
    //if (kpointsShouldBeHeap.size() > k) {
    //   kpointsShouldBeHeap.subList(0,k);
    //}
    return kpointsShouldBeHeap;
}

check this out.. Sie können finden Sie CLRS computational geometry Kapitel auch..
http://www.cs.ucsb.edu/~suri/cs235/ClosestPair.pdf