如何从2个列表中获取最近的2个点<Point>

Question

I have 2 Lists of Points:

        var listA = new List<Point>();
        listA.Add(new Point(10, 1));
        listA.Add(new Point(5, 5));
        listA.Add(new Point(15, 35));

        var listB = new List<Point>();
        listB.Add(new Point(1, 1));
        listB.Add(new Point(5, 4));
        listB.Add(new Point(35, 15));

Now I would like to do something like:

        getClosesPoints(listA,listB, Out pointA, Out pointB);

I'm currently at the point where i'm able to check a List again 1 Point

        private int NearestPoint(Point srcPt, List<Point> lookIn)
        {
            if (lookIn.Count == 1)
                return 0;

            KeyValuePair<double, int> smallestDistance = new KeyValuePair<double, int>();

            for (int i = 0; i < lookIn.Count; i++)
            {
                double distance = Math.Sqrt(Math.Pow(srcPt.X - lookIn[i].X, 2) + Math.Pow(srcPt.Y - lookIn[i].Y, 2));

                if (i == 0)
                    smallestDistance = new KeyValuePair<double, int>(distance, i);
                else if (distance < smallestDistance.Key)
                        smallestDistance = new KeyValuePair<double, int>(distance, i);
            }

            Console.WriteLine("smallest Distance:" + smallestDistance.Key);
            return smallestDistance.Value;
        }

But I'm not sure how to expand this code to check 2 Lists.

Answer 1

I'm assuming that you want the find the closest two points in two lists, where one of the points is in one list and the other point is in the other list.

You can solve this by using an inner and an outer loop. The outer loop iterates through all the points from the first list; for each of those points you use an inner loop to compare it with all the points from the second list.

You then don't need to remember all the distances; you just need to remember the distance between the two closest points that you have found so far, and the closest points so far themselves.

You can also create a simple little class just to return the closest two points rather than returning the results via out parameters. For convenience you can add a Distance() function to this class so you don't need to store the actual distance. (However if you were using this value frequently then you might want to cache the distance in a local field rather than calculating it each time.)

Finally, the parameters to the FindClosestPoints() method can be IEnumerable<Point> rather than List<Point> which allows you to use it with many more collection types.

Putting that all together gives something like this (a compilable console app):

using System;
using System.Collections.Generic;
using System.Drawing;

namespace Demo
{
    // Class just used to return the result from FindClosestPoints()

    public sealed class ClosestPoints
    {
        public ClosestPoints(Point p1, Point p2)
        {
            _p1 = p1;
            _p2 = p2;
        }

        public Point P1 { get { return _p1; } }
        public Point P2 { get { return _p2; } }

        public double Distance()
        {
            double dx = P1.X - P2.X;
            double dy = P1.Y - P2.Y;

            return Math.Sqrt(dx*dx + dy*dy);
        }

        private readonly Point _p1;
        private readonly Point _p2;
    }

    public static class Program
    {
        public static void Main()
        {
            var listA = new List<Point>();
            listA.Add(new Point(10, 1));
            listA.Add(new Point(5, 5));
            listA.Add(new Point(15, 35));

            var listB = new List<Point>();
            listB.Add(new Point(1, 1));
            listB.Add(new Point(5, 4));
            listB.Add(new Point(35, 15));

            var answer = FindClosestPoints(listA, listB);

            Console.WriteLine("Closest points are {0} and {1}", answer.P1, answer.P2);
        }

        public static ClosestPoints FindClosestPoints(IEnumerable<Point> seq1, IEnumerable<Point> seq2)
        {
            double closest = double.MaxValue;
            ClosestPoints result = null;

            foreach (var p1 in seq1)
            {
                foreach (var p2 in seq2)
                {
                    double dx = p1.X - p2.X;
                    double dy = p1.Y - p2.Y;

                    double distance = dx*dx + dy*dy;

                    if (distance >= closest)
                        continue;

                    result = new ClosestPoints(p1, p2);
                    closest = distance;
                }
            }

            return result;
        }
    }
}

Answer 2

If you return the entire Key-Value-Pair from your method, you would be able to expand from one point to the whole list using a simple loop:

KeyValuePoint<double,int> best = new KeyValuePair<double,int>(double.MaxValue, -1);
int best2 = -1;
for (int i = 0 ; i != list2.Count ; i++) {
    Point pt = list2[i];
    KeyValuePoint<double,int> current = NearestPoint(pt, list1);
    if (current.Key < best.Key) {
        best = current;
        best2 = i;
    }
}

At the end, best.Key has the shortest distance, best.Value has the index of the point in list1 , and best2 has the index of the point in list2 .

Answer 3

Let us call the two sets of points as S1 and S2. Let p1 be the iterator for S1 and p2 the iterator for S2. Let valueAt be a function which tells the value at iterator position (like p1 or p2). Let dist be a function which computes the distance between two points. And, let dmin be the variable which will hold the distance between two points.

Assuming that these two sets can contain negative values as well, I propose the following logic :

• sort S1 and S2

• if valueAt (p1) < valueAt (p2)
  { d = dist (p1, p2 ); if ( dmin > dist ( p1, p2 ) ) { dmin = dist (p1, p2); record p1 and p2 as closest; }

   increment p1; 

  }

• if valueAt (p1) > valueAt (p2)
  { d = dist (p1, p2 ); if ( dmin > dist ( p1, p2 ) ) { dmin = dist (p1, p2); record p1 and p2 as closest; }

   increment p2; 

  }

• if valueAt (p1) == valueAt (p2)
  { record p1 and p2 as closest; }