算法找到附近的朋友？

Question

I have a python program sitting in server side managing user location informations, each friend has a pair of (longtitude, latitude), given a (longtitude, latitude) point, how I can find the nearby(say within 5KM) friends efficiently?

I have 10K users online...

Thanks. Bin

Answer 1

New Answer:

I would store lat and long in separate columns. Place indexes on them. Then when you want to find the nearby friends of a particular user, just do something like

select field1, field1, ..., fieldn from users 
where 
    user_lat > this_lat - phi and user_lat < this_lat + phi
    and
    user_lon > this_lon - omega and user_lon < this_lon + omega

where phi and omega are the degrees of latitude and longitude that correspond to your desired distance. This will vary depending on where on the globe you are but there are established equations for figuring it out. There's also the possibility that your database can do those calculations for you.

---

old answer.

I would look at quadtrees and kd-trees .

Kd-trees would be the canonical solution here, I believe.

Answer 2

A simple way would be to sort the points along the longtitude, then, when looking up friends, find the minimum and maximum longtitudes of possible matches. Sorting the list is O(n log n), and looking up for friends is linear, but only for friends within the longtitude range. Here's an example for the case where you have all the points on a flat 2D surface:

# friends is the sorted list of (x, y) tuples, (px, py) is my location
def get_near(friends, px, py, maxdist):
    i1 = bisect.bisect_left(friends, (px - maxdist, py))
    i2 = bisect.bisect_right(friends, (px + maxdist, py))
    return [(x, y) for (x, y) in friends[i1:i2] if math.hypot(px - x, py - y) < maxdist]

For the longtitude/latitude case, you'd have to use another function for testing for distance instead of the euclidean distance(math.hypot).

Answer 3

Make a dict {graticule: [users]} (a "graticule" is a block of 1 degree latitude x 1 degree longitude; so you can basically just round the values). To find nearby users, first get users from the same and adjacent graticules (since the target could be near an edge), then filter them with a basic bounding-box test (ie what are the minimum longitude/latitude that are possible for someone within the desired radius), then do a detailed test (if you need accuracy then you are in for some more complex math than just Pythagoras).

Answer 4

http://www.movable-type.co.uk/scripts/latlong.html in terms of efficiency the only thing that's really coming to mind is pre-computing the distance as entries are made into the database, that is have another table that stores a pair of locations along with the distance, for each location that's added at the time it's added you'd incur the cost of calculating it's distance to every other point in the system but then lookups on this table could quickly resolve locations within a certain distance.

Aaronasterling's answer appears to be what I was trying to think through by myself but didn't know existed :) so it's probably a better solution, but I'm sure you'll incur something of overhead at search time using that algorithm (albeit probably small since generally traversing a tree so long as it's reasonably balanced is usually a pretty fast process, going to take me some time to understand exactly how the tree is composed still that one's a new concept to me).