Graph-Indexed kNN Query Optimization on Road Network

Abstract

The nearest neighbors query problem on road networks constitutes a crucial aspect of location-oriented services and has useful practical implications; e.g., it can locate the k-nearest hotels. However, researches who study road networks still encounter obstacles due to the method’s inherent limitations with respect to object mobility. More popular methods employ indexes to store intermediate results to improve querying time efficiency, but these other methods are often accompanied by high time costs. To balance the costs of time and space, a lightweight flow graph index is proposed to reduce the quantity of candidate nodes, and with this index the results of a kNN query can be efficiently obtained. Experiments on real road networks confirm the efficiency and accuracy of our optimized algorithm.

1. Introduction

The nearest neighbors (top-k nearest neighbors (kNN)) query in a road network is an essential problem in location-based services. The kNN search is applied in various practical contexts. For example, when using hospitality reservation services such as Tongcheng-Elong, it is crucial to show a range of venues near the user’s location. Similarly, in vehicle-for-hire platforms like Didi Chuxing, it is advantageous to offer a variety of vehicles within a short distance of the user.

Given a road network G(V,E), a set of candidate objects M, and a query vertex q, the goal is to find the k objects in M that are closest to q. Figure 1 shows the example of a road network G, a moving object $m_1$ is on the edge from $v_6$ to $v_3$, $dist(v_3,v_6)$ = 2, assuming all vertices are candidates. Given a query vertex $v_3$, the four nearest neighbors of $v_3$ are $v_3$, $v_6$, $v_7$, and $v_{10}$, with shortest network distances to $v_3$ of 0, 2, 3, and 4, respectively; then, the three nearest moving objects are $m_1$, $m_2$, and $m_5$.

The kNN query problem on a road network has seen various research results. The most simple and direct solution is to use Dijkstra’s algorithm [1]; i.e., given a query vertex q, search for vertices in order of non-decreasing distance from other vertices to q, ending when k vertices are found. Although this method is simple, the time cost is high, especially when the dataset is relatively large. The state-of-the-art algorithm for the kNN problem in road networks is TEN-Query [2], using the TEN-Index, which is based on tree decomposition. Mapping the graph into a tree structure, the kNN results for each vertex are precomputed and stored in the index. However, the establishment of the index is limited by the value of k, and the algorithm cannot perform queries when k increases. We have designed an index that breaks this limit by storing all candidate vertices in the local range of each vertex. Using a new tree decomposition generation algorithm, an average weight generation algorithm is used to construct tree decomposition.

The main contributions of this paper are as follows:

(1)

Conventional tree decomposition is refined based on the minimum degree principle, and we propose an flow graph index generated from a graph-decomposed tree, which can effectively preserve distance information within the road network;

(2)

Based on the flow graph index, the kNN query algorithm is proposed to significantly reduce the retrieval space of candidate nodes; thereby, it can enhance the performance of kNN queries in road networks;

(3)

Experiments on real road networks confirm the efficiency and accuracy of the proposed algorithm.

The remainder of this paper is organized as follows. Section 2 reviews related literature. Section 3 describes the problem. Section 4 explains the index-construction methodology and query algorithm. Section 5 reviews our findings. Section 6 presents our conclusions.

2. Related Work

The kNN query can be based on Euclidean space or a transportation network. We concentrate on kNN queries within relaxation networks, which can be in either a static or dynamic environment.

The most elementary solution for kNN queries is Dijkstra’s algorithm. Given a query point q, the algorithm searches for vertices in non-decreasing order of distance from the remaining vertices, stopping when k objects are found. Although effective, this is time-consuming, especially in large networks and when candidate objects are far away.

The grid-based index is a typical index structure in road network queries. D. He et al. [3] proposed a grid-based kNN index, GLAD, dividing road networks into $2^x$·$2^x$ grids according to the vertex latitude and longitude, maintaining a list of contained objects for each grid. To answer a kNN query, GLAD searches for objects starting from the mesh containing the queried vertices and updates the results by exploring adjacent meshes.

Dong Tianyang et al. [4] introduced direction-aware kNN (DAKNN) for moving objects on road networks, which employs an R-tree and a simple grid as fundamental structures to index the static road network and moving objects, respectively. An azimuth represents the moving direction of a target in the road network, and a local network extension method is used to quickly judge the direction of the moving target.

Graph partition-based indices are also used in kNN queries. Bilong Shen et al. [5] proposed a V-tree index to support efficient kNN searches and dynamic updates for moving objects. They iteratively divide the road network into sub-networks, build a tree structure on top of these, and associate a moving object with the nearest vertex in the V-tree. When updating the position of an object, only the tree nodes on the path from the corresponding leaf node to the root must be updated.

Zhong R et al. [6] proposed a balanced search tree index, G-tree, recursively dividing a road network into sub-networks, where each G-tree node corresponds to a sub-network. They introduced a best-first search algorithm on road networks, and an assembly-based approach to efficiently compute the minimum distance from a G-tree node to a query location. Li Z et al. [7] proposed G*-tree, an improved kNN index structure, establishing shortcuts between selected leaf nodes to address the low query efficiency of G-tree.

Dan T et al. [8] proposed LG-tree, which partitions large graphs into subgraphs and indexes these using balanced trees. LG-tree constructs a hierarchical structure based on Dynamic Index Filtering (DIF) and boundary vertices, using stage-based dynamic programming to ensure the efficiency of the shortest distance search.

Bao JL [9] introduced the index structures used in nearest neighborhood queries, discussed current challenges, and explored future research focuses on nearest neighbor query techniques in road networks. Li L et al. [10] addressed the problem of continuously reporting alternative paths for users traveling along a given path by accessing vertices in ascending order of maximum depth value, so as to improve computational efficiency and enhance accuracy. Yuan-Ko Huang et al. [11] addressed the kNN skyline in dynamic road networks, conducting queries using three data structures: object attribute control matrix (OADM), road distance ranked list (RDSL), and skyline object extension tree (SOET). R. Halin et al. [12] introduced the concept of tree decomposition in 1976, expediting graph problem calculations by mapping graphs into tree structures. Dian Ouyang et al. [13] built on this with H2H-Query, a method to efficiently calculate the shortest distance between two vertices on a road network. The shortest distance for each vertex in each ancestor node is stored, enabling the most straightforward network distance calculation between any two points in $O\left(w\right)$ time. They subsequently proposed a tree-decomposition-based index, TEN-Index, which precalculates the shortest distance from each vertex to its ancestor vertex and stores each vertex’s local kNN, which reduces query times and enhances kNN performance.

There are other kNN indices and algorithms. Hyung-Ju et al. [14] proposed an efficient continuous search algorithm, UNICONS, using Dijkstra’s shortest path algorithm and a precalculated NN list to enhance NN query performance. Maytham Safar [15] used network distance rather than Euclidean distance as the shortest path metric. Guang Zhong Sun [16] suggested a straightforward, effective precomputation technique for kNN calculations on extensive road networks, selecting a suitable representative node set R (a subset of V) from road network G(V,E) and precomputing the distance value for any pair in R.

In response to the natural extension of kNN queries for multiple moving objects, i.e., Aggregate k Nearest Neighbor ($Ak$NN) queries, Abeywickrama T [17] proposed the Compressed Object Landmark Tree (COLT) data structure, which implements efficient hierarchical graph traversal and performs various aggregation functions effectively. Bareche I et al. [18] proposed a Velocity Spatiotemporal (VeST) indexing approach for continuous queries, mainly Continuous K-Nearest Neighbor ($CK$NN) and continuous range queries using Apache Spark. The proposed structure is based on a selective velocity-partition method, which reduces the update cost and improves the response time and query accuracy. Ying Ju Chen et al. [19] proposed the SQUARE algorithm, constructing a network index resembling the decoupling model while using coupling concepts to maintain kNN information relative to hotspot areas in the network index. Hotspots represent areas where frequent queries are found in history. Aye Thida Hlaing et al. [20] proposed a fast $Rk$NN search algorithm using Simple Materialized Path View (SMPV), employing an Incremental Euclidean Restriction (IER) strategy for swift kNN queries. Luo et al. [21] proposed an index-based kNN query solution, Toain, based on a shrinkage hierarchy, and utilizing a shortcut-based index, SCOB, to accelerate query processing. Chuanwen Li et al. [22] proposed a kNN query algorithm using an index structure based on a lazy update strategy, capitalizing on both CPU and GPU resources. The region being queried is first identified, and the GPU is used to update the index for that region. The index is queried using the GPU and a candidate result set is generated, which is refined by the CPU to obtain the final result.

3. Problem Definitions

We study the kNN query problem on road networks based on tree decomposition, with symbols as defined in

Table 1. Symbol Definitions.

Symbol	Definition
$X\left(v\right)$.extList	Node expansion list of node $X\left(v\right)$, sorted in ascending order of road network distance from node $X\left(v\right)$
$v{.}_{isCandidate}$	Whether vertex v is a candidate vertex
dist($v_1,v_2$)	The true shortest road network distance from vertex $v_1$ to vertex $v_2$
curDist(($v_1,v_2$)|p)	The current shortest road network distance from vertex $v_1$ to vertex $v_2$ along path p
R	kNN set of query point q, sorted in ascending order of road network distance from q
root	The root of the kNN index
threshold	Threshold
M	Candidate vertex set

.

The road network is modeled as a weighted undirected graph G(V,E), where V is a vertex set and E is an edge set. For an edge $e(v_1,v_2)$, weight $w\left(e\right)$ or $w(v_1,v_2)$ represents the length of the edge. A path p is a vertex sequence $p=(v_1,v_2,\dots ,v_k)$, where for any $1\le i<k$, $(v_i,v_{i+1})\in E$, the weight of p is expressed as $\phi \left(p\right)={\sum }_{i=1}^{k-1}\phi (v_i,v_{i+1})$ given two vertices $v_1$ and $v_2$; the shortest path between them is a path p from $v_1$ to $v_2$ that satisfies $w\left(p\right)$ as s minimum. In this paper, $\mathrm{dist}(v_1,v_2)$ is used to represent the length of the shortest path from $v_1$ to $v_2$.

We study the road network kNN query in a static environment, i.e., when both the query point and candidate object are static. For the dynamic road network kNN query, the dynamic moving candidate object can be mapped into offset neighboring vertices; thus, it can be transformed into a static environment. Specifically, given a query point q and a moving object m, assuming that q is located on the edge $e_1=(v_s,v_e)$, the distance from the vertex $v_e$ is $d_q$, m is located on the edge $e_2=(v_s^{\prime },v_e^{\prime })$, and the distance to the vertex $v_s^{\prime }$ is $d_m$. Then, the distance between q and m is expressed as $\mathrm{dist}(q,m)=\mathrm{dist}(v_e,v_s^{\prime })+d_q+d_m$. This paper defines the kNN query problem as follows.

Definition 1 

(kNN Query). Given a road network $G(V,E)$, a query point q, an integer k, and a set of candidate vertices M ($\left|M\right|>k$), the kNN query aims to calculate a set R that satisfies:

1. 

$\left|R\right|=k$;

2. 

$R\subset M$;

3. 

$\forall v\in R$, $\forall v^{\prime }\in M-R$, $\mathit{dist}(q,v)\le \mathit{dist}(q,v^{\prime })$

In the road network shown in Figure 2, there are ten vertexes, the distance between $v_2$ to $v_3$ is 6, given the query point $v_3$, with $k=3$, and dotted line vertices (such as $v_1$, $v_5$, $v_6$, $v_8$, and $v_{10}$) are candidate vertices, the 3NN of $v_3$ in the candidate vertices is $R=\{v_6,v_{10},v_8\}$, and their shortest network distances to $v_3$ are 2, 4, and 5, respectively.

Notably, due to the potential for identical edge weights, the kNN for each vertex may need more uniqueness. This factor does not compromise the algorithm’s validity, as presented in this treatise.

4. Index and Algorithm

We present the solution to the kNN problem on road networks, using an amalgamated index structure, Average Weight Tree Decomposition with Ancestor Table and Children Table (AWTDAC).

4.1. Average Weight Tree Decomposition Index Construction

Definition 2 

(Tree Node). For each vertex v in the road network $G(V,E)$, its corresponding tree node is denoted by $X\left(v\right)$, $X\left(v\right)$ represents a subset of the road network vertex set V, comprising vertex v and its neighboring vertices. In this paper, v is referred to as the principal vertex of $X\left(v\right)$ and is denoted in gray, symbolized by $X\left(v\right).\mathit{grayId}$. The neighboring vertices of v are considered adjacent vertices of $X\left(v\right)$.

Taking the road network shown in Figure 1 as an example, Figure 3 depicts the tree node $X\left(v_3\right)$ corresponding to vertex $v_3$, where $v_3$ serves as the principal vertex, and $v_1$, $v_4$, and $v_8$ constitute adjacent vertices. The calculation process of the specific values of the adjacent vertices of $v_3$ is based on the average weight tree decomposition process. The result comes from the constructed decomposition tree.

Tree decomposition [5] accelerates the computation of numerous graph problems by mapping graphs onto tree structures and is defined as follows.

Definition 3 

(Tree Decomposition). Given a graph $G(V,E)$, its tree decomposition is denoted $T_G$, and is composed of several tree nodes with the set of all tree nodes represented as Λ. $T_G$ satisfies the following conditions:

(1) 

$\cup X\left(v\right)\in \Lambda X\left(v\right)=V$.

(2) 

For each edge $e(v_1,v_2)\in E$ in G, there must exist a tree node $X\left(v_3\right)\in \Lambda$, satisfying $v_1\in X\left(v_3\right)$ and $v_2\in X\left(v_3\right)$.

(3) 

For each vertex v in G, all tree nodes $X\left(v^{\prime }\right)$ containing v (i.e., $v\in X\left(v^{\prime }\right)$) constitute a connected subtree of $T_G$.

Definition 4 

(Tree Height and Tree Width). Given a tree decomposition $T_G$, this manuscript stipulates that the root node’s depth is 1, while the depth of other tree nodes is the depth of their parent node plus 1. Based on this, the tree height of $T_G$ is defined as the maximum depth of all tree nodes, denoted by h. The treewidth of $T_G$ is defined as the maximum number of adjacent vertices among all tree nodes, represented by w; that is,

$$w=\underset{X\left(v\right)\in \Lambda }{max}\left|X\left(v\right)\right|-1$$

(1)

Definition 5 

(Elimination Order). Given a graph $G(V,E)$, this manuscript sequentially removes vertices in G following a specific rule. For each currently deleted vertex v, $v.\mathit{deleteOrder}$ is utilized to record its removal order, referred to as the elimination order of vertex v.

For instance, considering the road network $G(V,E)$ depicted in Figure 1, vertex $v_6$ is the first to be removed; hence, $v_6.\mathrm{deleteOrder}=1$.

We briefly describe the generation process of tree decomposition. For any road network $G(V,E)$, the traditional tree decomposition generation algorithm is based on the principle of minimum degree (i.e., the vertex with the smallest degree in graph G) and it is divided into two stages.

Stage One: Vertex Removal. Select vertex v with the smallest degree in G each time, and use v and its neighbors as tree nodes $X\left(v\right)$. For any pair of neighbors $(v_1,v_2)$ of v, if no edge exists between $v_1$ and $v_2$, add an edge $e(v_1,v_2)$, whose weight $w(v_1,v_2)=w(v_1,v)+w(v,v_2)$; if there is an edge $e(v_1,v_2)$ and $w(v_1,v_2)>w(v_1,v)+w(v,v_2)$, then update $w(v_1,v_2)$ to $w(v_1,v_2)=w(v_1,v)+w(v,v_2)$. Finally, delete v from G. Repeat this step until all vertices in G have been removed and record the elimination order of each vertex.

Stage Two: Tree Decomposition Construction. For each tree node $X\left(v\right)$ generated in Stage One, select the vertex $v^{\prime }$ with the smallest elimination order among the adjacent vertices of $X\left(v\right)$, designating $X\left(v^{\prime }\right)$ as the parent node of $X\left(v\right)$. Repeat this step until all tree nodes coalesce into a tree.

Figure 4 exhibits a tree decomposition created using the minimum degree principle for the road network G illustrated in Figure 1. The gray vertices are the principal vertices, like $v_1$ is the principal vertex, and $v_2$, and $v_9$ constitute adjacent vertices. In this paper, a tree decomposition is constructed by the average weight principle. Both the average weight principle and the minimum degree principle are important concepts in graph algorithms, each having advantages in different types of problems. The average weight principle typically provides better results in dealing with weighted graph problems because it considers the weights of all nodes, not just their degrees. The minimum degree principle, on the other hand, is more suitable for specific problems such as connectivity issues. The average weight principle can provide improvements compared to the minimum degree principle, especially in dealing with weighted graph problems. However, the minimum degree principle may be more effective in dealing with certain specific types of problems. Therefore, the choice of which principle to use depends on the specific problem being addressed and the characteristics of the data.

The proposed average weight tree decomposition builds upon the minimum degree principle. The deletion of vertices no longer adheres to the minimum degree principle but defines a priority $S\left(v\right)(\alpha ,\beta ,\gamma )$ instead, where $S\left(v\right).\alpha$ represents the average weight of vertex v, i.e., the sum of edge weights of v divided by its degree. $S\left(v\right).\gamma$ is the number of edges that must be added after deleting vertex v, and $S\left(v\right).\gamma$ is the ID of vertex v. For the vertices in G, priority is sorted according to $\alpha$; if $\alpha$ values are equal, sorting is based on $\beta$. Vertex v is removed after sorting $S\left(v\right)(\alpha ,\beta ,\gamma )$, and other operations remain unaltered. Figure 5 shows a tree decomposition generated based on the average weight principle for the road network G in Figure 1.

Using Figure 5 as an example, the tree height of $T_G$ is h = 6, and the tree width is w = 3, as the tree nodes within $T_G$ contain a maximum of three adjacent vertices. For example, $v_3$ serves as the principal vertex, and $v_1$, $v_4$, and $v_8$ constitute adjacent vertices. In the road network, utilizing tree decomposition is reasonable, since the tree width and height are significantly less than the total number of vertices in the road network.

An average-weight-based tree decomposition algorithm is presented as Algorithm 1, where lines 2–9 represent vertex deletion, and lines 10–13 represent the tree decomposition phase. Upon the algorithm’s completion, all tree nodes form a connected tree decomposition. The time complexity of Algorithm  1 is $O\left(n\right(w^2+log\left(n\right)\left)\right)$, where n is the number of vertices in G, and w is the tree width of tree decomposition $T_G$. The space complexity is $O\left(nw\right)$.

Algorithm 1: Average Weight Tree Decomposition Construction Algorithm ($G(V,E)$).

    The calculated tree decomposition has the following properties [12].

Proposition 1. 

For a graph G and its corresponding tree decomposition $T_G$, for any two distinct vertices, $v\ne v^{\prime }$ in G, $X\left(v\right)\ne X\left(v^{\prime }\right)$.

Proposition 2. 

Considering a graph G and a tree decomposition $T_G$, for any tree node $X\left(v\right)\in \Lambda$ and any vertex $v^{\prime }\in X\left(v\right)/v$, $X\left(v^{\prime }\right)$ is an ancestor of $X\left(v\right)$ in the tree node $T_G$.

Definition 6 

(Ancestor). With the tree decomposition $TG$ of G, for any tree node $X\left(v\right)\in \Lambda$, the ancestor of $X\left(v\right)$ is expressed as the set $X\left(v\right).\mathit{anc}$, and the ancestor table of the root node is specified in this paper as ∅. Utilize $X\left(v\right).\mathit{parent}$ to represent the parent node of $X\left(v\right)$. Consequently, the ancestor $X\left(v\right).\mathit{anc}=X\left(v\right).\mathit{parent}.\mathit{grayId}\cup X\left(v\right).\mathit{parent}.\mathit{anc}$.

Definition 7 

(Children). Given the tree decomposition $T_G$ of G, for any tree node $X\left(v\right)$, the child of $X\left(v\right)$ is symbolized as the set $X\left(v\right).\mathit{child}$. This paper stipulates that the leaf node’s child is ∅, employing $X\left(v\right).\mathit{childSet}$ to represent the principal vertex set of $X\left(v\right)$’s child node and the child of the non-leaf node $X\left(v\right)$.

$$X\left(v\right).child=\bigcup _{c\in X\left(v\right).childSet}^{}c\cup X\left(c\right).child$$

(2)

Upon obtaining a tree decomposition, the shortest network distance between two vertices can be computed in $O\left(w\right)$ time using the H2H-Index [13], where w is the tree width. This is currently the most sophisticated technique to calculate the shortest net distance between vertices in road networks.

For any pair of vertices q and v with the nearest common ancestor X, the shortest path network distance between them is shown, which is described in Dian Ouyang et al. [13]:

$$dist(q,v)=\underset{s\in X}{min}dist(q,s)+dist(s,v)$$

(3)

We introduce the proposed kNN index. Given a query point q, we traverse the ancestors and children of each vertex. For any other vertex v, there are three possible scenarios:

• If $v\in X\left(q\right).\mathrm{anc}$, then $\mathrm{dist}(q,v)$ has been pre-calculated, and $\mathrm{dist}(q,v)$ can be obtained in $O\left(1\right)$ time.
• If $v\in X\left(q\right).\mathrm{child}$, likewise, $\mathrm{dist}(q,v)$ can be obtained in $O\left(1\right)$ time.
• If $v\notin X\left(q\right).\mathrm{child}$ and $v\notin X\left(q\right).\mathrm{anc}$, according to Equation (3), the shortest path network distance between v and q must pass through a vertex u in their nearest common ancestor. Hence, $\mathrm{dist}(q,v)=\mathrm{dist}(q,u)+\mathrm{dist}(u,v)$. This paper can obtain $\mathrm{dist}(q,u)$ and $\mathrm{dist}(u,v)$ in $O\left(1\right)$ time, allowing the retrieval of $\mathrm{dist}(q,v)$ within $O\left(1\right)$ time.

In summary, for any other vertex v, this paper can obtain $\mathrm{dist}(q,v)$ in $O\left(1\right)$ time.

Definition 8 

(Node extension list). Given a tree decomposition $T_G$ of G, for any tree node $X\left(v\right)\in \Lambda$, the node extension list of $X\left(v\right)$ is denoted as the set $X\left(v\right).\mathit{extList}$, where $X\left(v\right).\mathit{extList}=X\left(v\right)/v\cup X\left(v\right).\mathit{child}$.

To enhance the algorithm’s efficiency, this paper arranges the vertices in $X\left(v\right)$’s node extension list in ascending order based on their road network distance to vertex v.

For instance, in the tree decomposition $T_G$, illustrated in Figure 5, $X\left(v_3\right).\mathrm{extList}=\{(v_6,2),(v_7,3),(v_{10},4),(v_4,5),(v_8,5),(v_9,5),(v_2,6),(v_1,9)\}$, with respective road network distances to $v_3$ of 2, 3, 4, 5, 5, 5, 6, and 9.

We were inspired by Sun et al. who put forward the idea of flow graph to serialize the processing graph [23]. According to the $T_G$ structure on average weight tree decomposition in Figure 5, if the relationship between two vertices belongs to the parent–child relationship, the edge between the two vertices is called a tree edge; otherwise, it is a non-tree edge. The direction of the tree edge is from the parent vertex to the child vertex, and the direction of the non-tree edge is the direction from the deleted vertex to its adjacent vertices; in Figure 6, the solid line indicates the tree edge, and the dashed line indicates the non-tree edge. It can be seen that $v_3$ is the parent vertices of $v_2$, $v_7$, $v_8$, and $v_9$, and the distances from child vertices to $v_3$ are 6, 5, 5, and 5. The adjacent vertices of $v_3$ are $v_4$, $v_1$, $v_8$.

Definition 9 

(Flow Graph). Given a directed label graph $F(V_F,E_F,L_F)$, where $V_F$ represents a set of vertices, $E_F$ is a set of edges, and $L_F$ represents a label function, assigning one or more labels to nodes in $V_F$. In this paper, $L_F$ can be expressed as distance from two vertices, the vertex that contains the moving object M and the number of moving objects.

Relying on average weight tree decomposition, we maintain a node extension list for each tree node, resulting in the kNN flow graph index structure depicted in Figure 6. If there is a parent-child relationship between two vertices, the edge between the two points is called a tree edge, otherwise it is called a non-tree edge. The direction of the tree edge is from the parent-child vertex to the child vertex. The direction of the non-tree edge is from the deleted vertex to its adjacent vertex. The solid line represents the tree edge and the dotted line represents the non-tree edge. The parent and child vertices of vertices $v_2$, $v_7$, $v_8$, and $v_9$ are $v_3$, and their distances to $v_3$ are 6, 5, 5, 5 respectively. The adjacent vertices of $v_3$ are $v_4$, $v_1$, $v_8$.

The space complexity of the kNN flow graph index is $O\left(n^2\right)$, where n is the total number of vertices in the road network. Using the flow graph index structure can completely preserve the index structure of the tree decomposition, and it can also save the weight between vertices and the information about the moving objects on the vertices.

Theorem 1 verifies the node completeness between the road network and the flow graph index.

Theorem 1. 

Given a node v, if there exists a neighbor node $v^{\prime }$ of v, the tree node $X\left(v^{\prime }\right)$ is a passing node on the path from root node r to v in the graph-decomposed tree Λ rooted by node r.

Proof of Theorem 1. 

Considering a node v and its neighbor nodes $N\left(v\right)$, node v can be abstracted as a tree node $X\left(v\right)$, satisfying $N\left(v\right)$=$X\left(v\right)$−v. If there exists a tree node $X\left(v^{\prime }\right)$, satisfying that $X\left(v^{\prime }\right)$ is a parent of $X\left(v\right)$, then $v^{\prime }$∈$X\left(v\right)$−v. $v^{\prime }$ is connected with all other neighbor nodes $X\left(v\right)$−v−$v^{\prime }$ after v is deleted. It is the same if there exists a tree node $X\left(v^{″}\right)$, satisfying that $X\left(v^{″}\right)$ is a parent of $X\left(v^{\prime }\right)$, such that $X\left(v^{″}\right)$∈ ($X\left(v\right)$−v−$v^{\prime }$) ∪ ($X\left(v^{\prime }\right)$−$v^{\prime }$). Similarly, all tree nodes abstracted from neighbor nodes of v can be found in a path from the root node to v.    □

In addition, a filtering rule can be defined to prune the redundant nodes for kNN searching on the road network, shown as Lemma 1

Lemma 1. 

Given a query node q and a data node v, if there exists a minimum common ancestor $v^{\prime }$ of q and v, the shortest path dist(q, v) is equal to the sum of shortest paths dist(q, $v^{\prime }$) and dist($v^{\prime }$, v).

Proof of Lemma 1. 

If there exists one other node $v^{″}$, satisfying the condition that the shortest path dist(q, v) is equal to the sum of shortest paths dist(q, $v^{″}$) and dist($v^{″}$, v), then there must exist one or more across-path edges to connect the node $v^{″}$. However, it is impossible that there exists one across-path edge in a graph-decomposed tree according to Theorem 1 because any node v and its neighbor nodes are only found in the path from root node r to v.    □

We present the index construction and update strategy. For each tree node in average weight tree decomposition, it is only necessary to compute its node extension list. The construction algorithm for the node extension list is shown as Algorithm 2, where lines 1–3 calculate the shortest network distance from adjacent vertices in $X\left(v\right)$ to v, adding it to the node extension list; lines 4–6 compute the child vertices of $X\left(v\right)$ and incorporate them into the node extension list; and line 7 sorts the node extension list. The time complexity of Algorithm 2 is $O\left(nw\right)$, where n is the total number of vertices in the road network, and w is the tree width of $T_G$.

Algorithm 2: Node Expansion List Construction Algorithm ($X\left(v\right)$)

Regarding index updates, each vertex v has a flag bit, $v{.}_{isCandidate}$, indicating its status as a candidate point, which is false when v ceases to be a candidate point. Consequently, index updates have time complexity $O\left(1\right)$.

4.2. Query-Processing Method Based on kNN Index

We examine the specifics of the query algorithm AWTDN.

Definition 10 

(Ancestor Relationship). Given any two vertices $v_1$ and $v_2$, within the average weight tree decomposition $T_G$, if $v_1\in X\left(v_2\right).\mathit{child}$ or $v_2\in X\left(v_1\right).\mathit{child}$, then $v_1$ and $v_2$ are said to possess an ancestral relationship.

Definition 11 

(Current Shortest Path Network Distance). Given vertices $v_1$ and $v_2$ with no ancestral relationship, and common ancestor $X\left(v_3\right)$, the current shortest network distance from vertex $v_1$ to vertex $v_2$ via vertex $v_3$ is represented as $\mathit{curDist}\left((v_1,v_2)\right|v_3)$, that is, $\mathit{curDist}\left((v_1,v_2)\right|v_3)=\mathit{dist}(v_1,v_3)+\mathit{dist}(v_3,v_2)$. Since $X\left(v_3\right)$ is the common ancestor of $X\left(v_1\right)$, $X\left(v_2\right)$, $\mathit{dist}(v_1,v_3)$ and $\mathit{dist}(v_3,v_2)$ can be found in $X\left(v_3\right).\mathit{child}$ without calculation.

To enhance algorithm efficiency, this paper introduces a threshold for pruning, initially set to infinity and updated accordingly when the result is set $\left|R\right|\ge k$.

To facilitate the explanation of the kNN query problem, for a given query point q, we use a triplet $(v_1,v_2,s)$ to suggest that $v_1$ via $v_2$ has the shortest network distance to query point q equal to s, with the intermediate point $v_2$ termed the base point.

The vertex expansion strategy of AWTDN has three steps.

Step 1: Insert the query point into the min-heap, process the first vertex p of the heap, and if p is a candidate point, add it to the result set R.

Step 2: Determine the relationship between p and the base point. (1) If p is a child of the base point, add the next vertex of p to the min-heap. (2) If p is an ancestor of the base point, add both the next vertex of p and the next vertex of the base point’s node extension list to the min-heap. (3) If the distance between vertex v and the query point in the heap is updated, add the next vertex of vertex v to the heap.

Step 3: Process the heap’s leading vertex, repeat the first two steps, and when the current road network distance from the heap’s leading vertex to the query point is no less than the threshold, the algorithm concludes.

Consider a 3NN ($q=v_3$, $k=3$) of the query vertex $v_3$ as an example. In the first step, $v_3$ is added to the min-heap, the first vertex p of the heap is processed, and the vertex $p=v_3$ is handled for the first time. As $v_3$ is not a candidate point, it is not processed. In the second step, with no ancestral or child relationship with the base point, the next vertex $v_2$ of $v_3$’s node extension list is added to the min-heap. Correspondingly, in the third step, the heap’s first vertex, $v_2$, is processed.

As mentioned earlier, this paper uses $\mathrm{curDist}\left(\right(q,v\left)\right|p)=\mathrm{dist}(q,p)+\mathrm{dist}(p,v)$ to denote the current shortest path network distance from vertex q to vertex v when passing through point p. Evidently, $\mathrm{curDist}\left(\right(q,v\left)\right|p)$ is the upper bound of $\mathrm{dist}(q,v)$. Since $\mathrm{dist}(q,p)$ and $\mathrm{dist}(p,v)$ are pre-calculated, $\mathrm{curDist}\left(\right(q,v\left)\right|p)$ can be retrieved in constant time.

We present a lemma that supports the development of our query algorithm and two theorems that guide it and demonstrate its correctness.

Lemma 2. 

For any given vertices q and v, if v is a kNN of q, there must exist a vertex $p\in X\left(q\right).\mathit{extList}\cup \left\{q\right\}$ such that v satisfies the following: (i) $v\in X\left(p\right).\mathit{child}$; (ii) $\mathit{dist}(q,v)=\mathit{dist}(q,p)+\mathit{dist}(p,v)$.

As an illustration, consider Figure 6. Assume all vertices are candidate points, and given $q=v_3$ and $v=v_5$. For $\left\{v_3\right\}\in X\left(v_3\right).\mathrm{extList}$, we have $S=\{v_3,v_1,v_4,v_8\}$. There exists a vertex $p=v_8$ in S such that the shortest path from $v_3$ to $v_5$ passes through vertex $v_8$.

Based on Lemma 2, we propose our query algorithm. For a given query point q, we scan each vertex p in $\left\{q\right\}\cup X\left(q\right).\mathrm{extList}$. We first determine whether p is a candidate point. If so, we compare it with the last vertex in result set R, and update R accordingly. We then assess the relationship between p and the base point and process it accordingly.

Theorem 2. 

For a query vertex q, vertex v, and their common ancestor p, if $\mathit{curDist}\left(\right(q,v\left)\right|p)\ge \mathit{threshold}$, then vertex v cannot be a kNN of q.

Proof of Theorem 2. 

Given a query vertex q, assume that there is a vertex v and their common ancestor p, satisfying $\mathrm{curDist}\left(\right(q,v\left)\right|p)\ge \mathrm{threshold}$, and v is a kNN of q. Let R be the kNN set of q. It is easy to know that when $\mathrm{threshold}\ne +\infty$, there is $\left|R\right|\ge k$, and for any point $v^{\prime }$ in R, there is $\mathrm{dist}(q,v^{\prime })\le \mathrm{threshold}$, so there is $\mathrm{dist}(q,v^{\prime })\le \mathrm{threshold}\le \mathrm{curDist}\left((q,v)\right|p)$, and from the definition of kNN, we can know that v is not the kNN of q, which contradicts the hypothesis. The proof is completed.    □

Based on Theorem 1 and the ascending order feature of the node expansion list, when $\mathrm{curDist}\left(\right(q,v\left)\right|p)\ge \mathrm{threshold}$, then the vertex v and the vertices after v in the node expansion list must not be kNN of q, so we can exit the calculation early.

Theorem 3. 

Assume that in $\left\{q\right\}\cup X\left(q\right).\mathit{extList}$, the algorithm is currently processing vertex p, and it terminates when $\mathit{dist}(q,p)\ge \mathit{threshold}$. At this point, for any vertex v in the result set R, $\mathit{curDist}\left((q,v)\right|v^{\prime })=\mathit{dist}(q,v)$ holds, where $v^{\prime }$ is any common ancestor of q and v.

Proof of Theorem 3. 

Let v be any vertex in the result set R. Given the termination condition, for any vertex $p_{\mathrm{after}}$ processed after p (based on the sequence of scanning in $\left\{q\right\}\cup X\left(q\right).\mathrm{extList}$), by the property of ascending order in node expansion lists, if $v\in X\left(p_{\mathrm{after}}\right).\mathrm{child}$, then we have $\mathrm{dist}(q,p_{\mathrm{after}})+\mathrm{dist}(p_{\mathrm{after}},v)\ge \mathrm{threshold}$. Considering that $\mathrm{curDist}\left((q,v)\right|v^{\prime })\le \mathrm{threshold}$ and $v^{\prime }$ is any common ancestor of q and v, $\mathrm{curDist}\left((q,v)\right|v^{\prime })\le \mathrm{threshold}$; the proof is complete.    □

The pseudocode of AWTDN is shown as Algorithm 3. For each vertex p in $\left\{q\right\}\cup X\left(q\right).\mathrm{extList}$, if the shortest network distance from p to q is not less than the threshold (line 5 of Algorithm 3), the algorithm terminates because no more kNNs of q will appear. Then, we evaluate p; if p is a candidate point, we update the result set R and the threshold.

Algorithm 3: kNN Searching Algorithm basd on Graph-Decomposed Tree.

The space complexity of the graph-decomposed tree is $O(\Lambda )$=$\frac{\left|V\right|\left(\right|V|+1)}{2}$+$\left(\right|V|-1)$ in the worst case, where each node can be connected by all other nodes, the number of tree edges is $\left|V\right|-1$. The time complexity of the graph-decomposed kNN searching algorithm is $O\left(q\right)$=$\left|V\right|-1$ for query node q, because the nearest nodes can be found in the tree nodes $X\left(q\right)$ on the graph-decomposed tree $\Lambda$.

For example, given a query point q = $v_3$, k = 3, suppose the candidate set $M=\{v_1,v_5,v_6,v_8,v_{10}\}$ (i.e., the vertices of dotted lines in Figure 2), and we query the 3NN of $v_3$.

Table 2. kNN solution process of $v_3$ (q = $v_3$, k = 3).

Currently Processed Vertex	Candidate Point	Result Set	Relationship with Base Point	Extended Vertex Label	Min-Heap	Threshold
$(v_3,\varnothing ,0)$	No			$(v_6,v_3,2)$	$(v_6,v_3,2)$	$+\infty$
$(v_6,v_3,2)$	Yes	$(v_6,2)$	Child	$(v_7,v_3,3)$	$(v_7,v_3,3)$	$+\infty$
$(v_7,v_3,3)$	No	$(v_6,v_3,2)$	Child	$(v_{10},v_3,4)$	$(v_{10},v_3,4)$	$+\infty$
$(v_{10},v_3,4)$	Yes	$(v_6,2)$,$(v_{10},4)$	Child	$(v_4,v_3,5)$	$(v_4,v_3,5)$	$+\infty$
$(v_4,v_3,5)$	No	$(v_6,2)$,$(v_{10},4)$	Ancestor	$(v_8,v_3,5)$, $(v_1,v_4,14)$	$(v_8,v_3,5)$, $(v_1,v_4,14)$	$+\infty$
$(v_8,v_3,5)$	Yes	$(v_6,2)$,$(v_{10},4)$, $(v_8,5)$	Ancestor	$(v_9,v_3,5)$, $(v_1,v_8,14)$, $(v_5,v_8,17)$	$(v_9,v_3,5)$, $(v_1,v_8,14)$, $(v_5,v_8,17)$	$+\infty$
$(v_9,v_3,5)$	No	$(v_6,2)$,$(v_{10},4)$, $(v_8,5)$	Child	$(v_2,v_3,6)$, $(v_1,v_9,14)$, $(v_5,v_9,17)$	$(v_2,v_3,6)$, $(v_1,v_9,14)$, $(v_5,v_9,17)$	5

shows the process. The meaning of triplet representation is as mentioned above. In rows 3–5 of Table 2, the relationship between $v_6$, $v_7$, $v_{10}$, $v_9$, $v_2$, and the base point $v_3$ is as follows. All are children of $v_3$, so we add the subsequent vertices in the extended list of $v_3$ nodes to the heap. In line 6, $v_4$ is the ancestor of base point $v_3$, so we must add the subsequent vertices in the extended lists of nodes $v_3$ and $v_4$ to the heap; note that at this time, the first vertex of the $v_4$ node expansion list is $v_1$, and $\mathrm{dist}(v_4,v_1)=14$, $\mathrm{dist}(v_3,v_4)=9$. Also, $\mathrm{dist}(v_3,v_4)$ + $\mathrm{dist}(v_4,v_1)$ > $\mathrm{dist}(v_3,v_1)$. Hence, the shortest distance from $v_4$ to $v_3$ through $v_1$ is greater than the shortest distance from $v_1$ itself to $v_3$, so $v_1$ does no processing, and we add the follow-up vertex $v_5$ of $v_4$ to the heap. In the last line, the first vertex of the heap in the small root heap is $v_2$, and its label is ($v_2$,$v_3$,6); i.e., the shortest distance from $v_2$ to the query point after $v_3$ is 6, which is greater than the threshold of 5 at this time. So, the algorithm ends and returns R=($v_6$,2),($v_{10}$,4),($v_8$,5), indicating that the 3NN of $v_3$ is $v_6$, $v_{10}$, $v_8$, and their respective shortest distances to the query point are 2, 4, and 5.

This example helps illustrate the efficiency of AWTDN in handling kNN queries. The algorithm can use the precomputed shortest distances and a threshold value to prune unnecessary computations, improving overall performance.

By focusing on an average weight tree decomposition instead of on the minimum degree, we can more accurately capture the inherent structure of the road network. It visits fewer vertices for a given query point, which increases computational efficiency, as the number of visited vertices of a query point q is much smaller, as confirmed by our experiments, because average weight tree decomposition better preserves the distance information on the road network. On average, the vertices are similar to those in intermediate weight tree decomposition.

4.3. kNN-Query-Processing Method in a Dynamic Environment

We focus on the kNN query problem in a dynamic road network environment, where the candidate points are moving objects. Specifically, given a query point q, we must find the k moving objects that are closest. Since the positions of moving objects change with time, we use the offset method to map them to the nearest road network vertex and then convert the query from a dynamic environment to a static environment.

Considering the directionality of moving objects, we model the road network as a directed weighted graph $G(V,E)$.

Definition 12 

(Moving Object). Each moving object on the road network is represented by m = < $(v_i,v_j),\mathit{offset},t>$; that is, at time t, moving object m is on edge $(v_i,v_j)$, at an offset from vertex $v_j$.

For instance, referring to Figure 7, if the current time is t, moving object $m_{13}$ can be represented as $m_{13}$ = < ($v_3$,$v_2$),2,t>, meaning $m_{13}$ is on the edge between $v_3$ and $v_2$, the distance between $v_3$ and $v_2$ is 5 and the offset from vertex $v_2$ is 2. The algorithm maps each query point to the starting vertex with the offset. For example, if $q_1$ is located on edge ($v_2$, $v_1$), it is mapped to starting point $v_2$ with an offset of 1. Therefore, the distance between a moving object m =< $(v_i,v_j),offse{t}_1,t>$ and query point q =< $(v_s,v_t),offse{t}_2,t>$ can be represented as $offse{t}_1+\mathrm{dist}(v_j,v_s)+offse{t}_2$.

The location information of each moving object m is updated regularly. We use a moving object table to store this location information at a given moment. Figure 8 shows the location information of the moving objects on a road network at times t and $t+1$, where $v_{start}$ and $v_{end}$ are the respective start and end vertices of edge $(v_{start},v_{end})$; M is the set of moving objects on this edge; offset contains the offsets of the moving objects to the end vertex $v_{end}$, corresponding one-to-one with the moving objects in M; and $M_N$ is the number of moving objects in M.

Taking Figure 8 as an example, given query point $q_1$ and assuming that all moving objects are candidate objects, when we initiate a kNN query at time t, we first map the query point $q_1$ to the starting vertex with an offset; i.e., $q_1$⩽〈($v_2$, $v_1$), 1, t〉. Subsequently, all moving objects are offset to the vertices in their end direction, which become the candidate vertices. For example, moving object $m_{13}$ can be represented as $m_{13}$⩾〈($v_3$, $v_2$), 2, t〉; i.e., $m_{13}$ is on the edge $(v_3,v_2)$, with an offset of 2 from the vertex $v_2$. Similarly, each moving object is mapped to a vertex on the road network with an offset, and the final result is as shown in the Moving Object List at time t. In this way, we can use the AWTDN algorithm for kNN queries. For the kNN set, R=$\{v_1,v_2,\cdots ,v_K\}$ returned by AWTDN is not the true result. We must continue restoring the vertices in R to moving objects on the road network. Taking $v_1$ as an example, $M_N=1$; i.e., there is only one moving object on $v_1$, i.e., $m_{13}$. The final distance from $m_{13}$ to the query point $q_1$ is dist($m_{13}$, $q_1$) = dist($v_2$, $v_1$) + $q_1$.offset + $m_{13}$.offset= 0 + 1 + 2 = 3. The actual kNN result set is obtained after restoring all vertices to moving objects in turn. It is worth noting that some vertices have more than one moving object, such as vertex $v_2$, which has moving objects $m_{11}$ and $m_{13}$. Therefore, it is necessary to further screen the moving objects to obtain the final k results.

At time $t+1$, as shown, due to the changes in positions of moving objects, the vertices to which moving objects are offset may also change. For example, due to the change in the position of $m_{13}$, its offset vertex changes from $v_2$ at time t to $v_1$ at time $t+1$. At this point, we need to set $v_{2.isCandidate}$ to false and $v_{1.isCandidate}$ to true. We take Figure 9 as an example to explain the kNN query in a dynamic environment.

The starting vertex of query point q in Figure 9 is $v_3$. At time t, there are five moving objects, $m_1,m_2,m_3,m_4,m_5$. $m_1$ is on the edge ($v_3,v_6$), and the distance between $v_3$ and $v_6$ is 2. We map each to a terminating vertex with the offset.

Table 3. List of moving objects at time t.

${\mathit{v}}_{\mathit{end}}$	M	${\mathit{v}}_{\mathit{start}}$	$\mathit{Offset}$	${\mathit{M}}_{\mathit{N}}$
$v_6$	$m_1$	$v_3$	1	1
$v_{10}$	$m_2$	$v_3$	2	1
$v_5$	$m_3$	$v_8$	3	1
$v_1$	$m_4$	$v_9$	2	1
$v_8$	$m_5$	$v_7$	2	1

shows the moving object list at time t after mapping. $Offset$ = 1 means the distance from $m_1$ to $v_6$ is 1, $M_N$ = 1 means the number of the moving object on the edge ($v_3,v_6$) is 1. Then, for the vertices after mapping, we use AWTDN to obtain the result set R and restore its vertices to real moving objects according to the moving object list, so as to obtain the final kNN result. The solution process is shown in

Table 4. kNN solution process of q.

Object	Mapped Vertex	Currently Processed Vertex	⋯	Min-Heap	Threshold
∅	$v_3$	$(v_3,\varnothing ,0)$		$(v_6,v_3,2)$	$+\infty$
$m_1$	$v_6$	$(v_6,v_3,2)$	⋯	$(v_7,v_3,3)$	$+\infty$
$m_1$	$v_7$	$(v_7,v_3,3)$	⋯	$(v_{10},v_3,4)$	$+\infty$
$m_1$,$m_2$	$v_{10}$	$(v_{10},v_3,4)$	⋯	$(v_4,v_3,5)$	$+\infty$
$m_1$,$m_2$	$v_4$	$(v_4,v_3,5)$	⋯	$(v_8,v_3,5)$,$(v_1,v_4,14)$	$+\infty$
$m_1$,$m_2$,$m_5$	$v_8$	$(v_8,v_3,5)$	⋯	$(v_9,v_3,5)$,$(v_1,v_8,14)$, $(v_5,v_8,17)$	$+\infty$
$m_1$,$m_2$,$m_5$	$v_9$	$(v_9,v_3,5)$	⋯	$(v_2,v_3,6)$,$(v_1,v_9,14)$, $(v_5,v_9,17)$	5

. In the dynamic query, we must modify the kNN result set obtained by AWTDN. Suppose that the 4NN of query point q is 4NN = $\{v_6,v_7,v_{10},v_4\}$. If a vertex $v_8$ satisfies $\mathrm{dist}(v_8,$q) = $\mathrm{dist}(v_4,$q), then we continue to save $v_8$; i.e., the 4NN of q is 4NN = $\{v_6,v_7,v_{10},v_4,v_8\}$. This ensures that the real moving objects are not missed.

A moving object table stores the moving objects’ location information at specific time points, including information such as the starting and ending vertices of the edge on which the object is located, the set of moving objects on that edge, the offset of each object from the ending vertex, and the number of moving objects on the edge. This allows the transformation of the problem from dynamic to static, allowing the use of conventional static kNN algorithms.

5. Experimental Analysis

5.1. Experimental Parameters

We implemented the AWTDN algorithm in the Java language and compared it with TEN-Query [2] and G*Tree [7]. The experimental environment comprised an AMD Ryzen 9 5900X 12-Core CPU at 3.69 GHz, 64 GB of memory, a 4 TB hard drive, and Windows 10.

Dataset: The dataset came from real-world road networks provided by Urban Road Network [24]. Six sets were selected for experiments, as shown in

Table 5. Statistics of road network data.

Dataset	|V|	|E|	h	w
Quanzhou (QZ)	5672	7521	210	79
Dalian (DL)	13,605	17,984	209	65
Pune (PN)	28,649	36,925	359	144
Baghdad (BD)	60,108	88,876	560	201
Tehran (TR)	110,580	147,339	721	356
Bangkok (BK)	154,352	187,798	806	357

, where h and w are the respective height and width of average weight tree decomposition.

Parameter Configuration: For each dataset, we randomly generated candidate objects and controlled their numbers via object density $\theta$, defined as the ratio of the numbers of candidate objects and road network vertices. The configurations of $\theta$- and k-values can be found in

Table 6. Parameter Settings.

Parameters	Description	Value
k	Quantity of Nearest Neighbors	10, 20, 50, 100
$\theta$	Object Density	0.2, 0.3, 0.5, 0.7

, with default values written in boldface.

5.2. Impact of Dataset Size on Algorithm Query Time

We compared the query times of AWTDN, G*Query, and TEN-Query for different dataset sizes, where the object density $\theta$ and k take default values. We randomly generated 1000 vertices as query points, using the mean of all query times as the ultimate query time. The results are shown in Figure 10.

It is evident that both AWTDN and TEN-Query are significantly more efficient than G*Query, and AWTDN is the fastest. This is attributed to the avoidance of ineffective computations by applying thresholds. We compared the performance of the algorithms under varying k-values.

5.3. Impact of Changing k-Values on Algorithm Query Time

We compared the query efficiencies of the algorithms across six datasets by altering k-values, as shown in Figure 11.

The query performance varying different k-values is evaluated in Figure 11. A more stationary linearity of our algorithm is measured than G*Query and TEN-Query algorithms as the incremental changes of k-values. The flow graph index abstracts all nodes of the graph as the tree nodes, and the size of the tree nodes depends on the quantity of neighbors. Therefore, this tree is not related to the selection of k-value, which transcend the k-value limitation by storing all potential nodes.

5.4. Impact of Changing Object Density $\theta$ on Algorithm Query Time

We compared the query efficiencies of the three algorithms across six datasets by adjusting $\theta$ values, with results as shown in Figure 12.

It is apparent that, irrespective of changes in the $\theta$ value, the performance of AWTDN across all six datasets is markedly superior to that of TEN-Query and G*Query, thereby confirming the universal applicability of AWTDN.

5.5. Comparison of Accessed Vertex Numbers across Different Datasets

We compared the number of vertices accessed by AWTDN, TEN-Query, and G*Query across six datasets. For each dataset, we generated 1000 random query points and took the average total number of accessed vertices as the final count. Both k and $\theta$ took default values. The comparison results are shown in Figure 13.

The results reveal that AWTDN accesses significantly fewer vertices than TEN-Query and G*Query, which is attributable to the efficient pruning capacity of the threshold.

5.6. Comparison of Index Construction Time and Space across Different Datasets

We compared the index construction time and space of AWTDAC, TEN-Index, and G*Query across datasets of varying sizes, where the object density $\theta$ takes the default value of 0.3. Since the construction of TEN-Index depends on k, to accommodate queries of all k-values, we set k to 100. It is worth mentioning that AWTDAC does not rely on k and thus can satisfy kNN queries of any k-value. We set the parameters of G*Tree according to the original text. The comparison results are depicted in Figure 14 and Figure 15.

AWTDAC incurs higher construction time and space costs than TEN-Index, which only stores the kNN results within the contracted neighbor range, which explains why TEN-Index depends on the k-value. In contrast, AWTDAC stores all vertices within the subtree scope, thus breaking the k-value limitation and enabling kNN queries of any k-value. Although G*Tree has the smallest space cost, it has the largest time cost. G*Tree employs the Dijkstra algorithm to calculate the shortest path network distance, while AWTDAC and TEN-Index use H2H-Query to measure the road network distance, which is significantly more efficient than Dijkstra.

6. Conclusions

kNN queries for road networks are studied in this paper. Firstly, a flow graph index is proposed to store the intermediated results, which is generated from a graph-decomposed tree. Rules obtained from the flow graph index are found to reduce the quantity of candidate nodes. Secondly, the kNN query algorithm is used to conduct the final results on this flow graph index. Finally, the effectiveness and efficiency of our proposed algorithm are confirmed through experiments.