# Lets have a look spatial search algorithms

Spatial searches are a reality currently as Google maps are being used now and then to reach places, to find people and do many more things. However, there are certain organizations that work towards achieving it and it is they who make the process faster for everyone. The algorithms behind it is known as spatial indices and they ensure you locate the nearest services on the go and nearest apartments to a particular location, within seconds or even better, milliseconds. This **algorithm is foundation** to all companies working with maps, but they are also important in generating live traffic data and determining the labels for each position or location.

**What are some of the fundamental queries?**

There are two basic queries involved in this process. The nearest neighbours and the range of any service are the two pillars of this algorithm. Since each location is a point, there can be thousands of nearest points in case of city. Then, you need to calculate the distances of a set of points from the query points and then sort them by distance. From the sorted results, all you need to do is to return the promised number of items. However, this algorithm works fine for hundreds of points. But, when the density is of the order of millions, your algorithm will fail.

Hence, you need to look at a different angle of solution, namely the spatial trees. You need indexing of the nodes first to make this query and that requires a good deal of money. However, you may ask that you may need to change the data later on. Practically, the frequency of change is too little and hence, indexing is the key to quick searching techniques. As it is the case with other data structures, using the branch and bound method serves perfectly in this case.

**The different trees and algorithms**

There are two major tree algorithms at work in this case. The R-tree uses boxing techniques as a set of points is broken into a set of particular number of boxes and then each set is broken into the same number of boxes, creating a maze of boxes. Then, you get the R-tree to apply the sorting algorithm. K-D tree is another structure where, instead of boxes, you separate them into halves and continue doing that until you arrive at smallest portions.

The algorithms are quite similar because the separation occurs along the axis. Range search trees are a bit different since here; you get a manageable tree height even for a supremely huge number of data points. You need to implement a top-down approach and you can ignore the unnecessary boxes. So, instead of searching 1 million points, you need to search much lower number of points to arrive at the correct data, making the process much faster than ever.

**The nearest neighbour scenario**

This is particularly difficult since instead of the usual tactics defined here, you need to adhere to the priority queue. Such a queue will pick up the smallest one immediately from an ordered set. So, the nearest box, once opened, allows all the smaller boxes in the queue along with big ones. Once you continue, you can guarantee that the item removed is the nearest point. Hence, the boxes that are not opened yet will then consist of points that are farthest from the point, guaranteeing the validity of the algorithm.

Moreover, you can modify this search to build an algorithm for determining the points nearest to a straight line instead of a point. So, once you modify the search for a segment to box scenario, you get the required result.