KR100233365B1 - Hg-tree index structure and method of inserting and deleting and searching it - Google Patents

Abstract

The present invention relates to a new HG-tree index structure and its insertion, deletion and retrieval method for maximizing retrieval and update efficiency for data in multidimensional space such as multimedia database or geographic information system.

In detail, the HG-tree index structure of the present invention uses a Hilbert curve to map all positions in n-dimensional space to positions on a one-dimensional line segment and is represented by the directory portion of the index structure. The concept of minimum bounding interval (MBI) is introduced to minimize the area of data covered by the index node as much as possible so that the area represents as little of the actual data as possible.

In addition, when inserting a new data object, if an overflow occurs at a node of the index structure and the node needs to be separated, the neighboring node is checked for room. Redistribution of nodes to adjacent nodes prevents node separation, and if node separation is inevitable, two nodes are separated into three with one of the adjacent nodes to increase storage efficiency.

Description

HG-tree index structure and its insertion, deletion and retrieval methods

The present invention relates to a new HG-tree index structure and its insertion, deletion and retrieval method for maximizing retrieval and update efficiency for data in multidimensional space such as multimedia database or geographic information system.

Since the index structure provided by the conventional relational database system is almost one-dimensional based on B-tree, it is not suitable for processing data of multidimensional structure having complex structure such as multimedia data or geographic information. .

Currently, KDB-tree, buddy-tree, BANG file, hB-tree, multilevel grid file, R-tree There are index structures that support multidimensional data such as -tree), but they have the following problems.

First, when the data distribution is uniform, the performance is decent, but when the data are correlated or skewed, the performance is suddenly degraded. However, data distribution in actual situations tends to show a distribution that is related to each other or distorted rather than uniform.

Second, the directory part of the index structure should represent only the area containing the actual data to the minimum, which shows good performance when executing a range query or a neighbor neighbor query. However, since the conventional index structures do not represent the minimum portion of the directory area, satisfactory performance is not obtained when these queries are executed.

Third, data retrieval performance is highly dependent on storage utilization of the index structure. However, the storage efficiency of the conventional index structure is about 70% on average even in the case of a good index structure, the search efficiency was not very high. In addition, there is no low bound that can prove the worst case, so that the worst case can not prove the performance. Therefore, a sudden decrease in performance is expected when an accident occurs.

An object of the present invention is to provide a new HG-tree (Hibert Grid-tree) index structure that improves the search and update performance, and to insert, delete, and search methods thereof.

The HG-tree index structure of the present invention uses a Hilbert curve to map all positions in n-dimensional space to positions on a one-dimensional line segment, where the area represented by the directory portion of the index structure is actually occupied by the data. The concept of minimum bounding interval (MBI) is introduced to represent the minimum part, and the search performance is improved by reducing the data area covered by the index node as much as possible.

In addition, when inserting a new data object, if an overflow occurs at a node of the index structure and the node needs to be separated, the neighboring node is checked for room. Redistribution of nodes to adjacent nodes prevents node separation, and if node separation is inevitable, two nodes are divided into three together with one of the adjacent nodes to increase storage efficiency.

1A and 1B show the first and second Hilbert curves in a two-dimensional space

2A and 2B illustrate an index structure with and without an index boundary concept.

3 is a flowchart illustrating an insertion method for generating an HG-tree index structure.

4 is a detailed flowchart of a leaf node selection process of FIG.

5 is a detailed flowchart of the overflow processing generated in FIG.

6 is a detailed flowchart of the tree adjustment process of FIG.

7 is a flowchart illustrating a deletion method for updating an HG-tree index structure.

8 is a detailed flowchart of the underflow process of FIG. 7.

9 is a detailed flowchart of the tree adaptation process of FIG.

10 is a flowchart illustrating a method of searching for an exact match in an HG-tree index structure.

11 is a flowchart illustrating a region searching method in an HG-tree index structure.

12 is a detailed flowchart of the overlap process of FIG.

13A and 13B are flowcharts illustrating a maximum proximity search method in an HG-tree index structure.

The HG-tree of the present invention uses a space-filling curve called a Hilbert curve to increase storage efficiency. The space filling curve orders each position in n-dimensional space by mapping each position in n-dimensional space to a position on a one-dimensional line segment.

The Hilbert curve is known to have the largest clustering effect among the currently known space filling curves. The greater the dense effect, the better the index structure. 1A and 1B show the first and second Hilbert curves H ₁ and H ₂ in two-dimensional space.

Hilbert curves are used to map all locations in n-dimensional space to locations on a one-dimensional line segment. This gives a one-dimensional ordering between all data objects and index nodes, and all index nodes have well-defined sibling nodes.

Thus, node overflow can be prevented by distributing data of flood nodes to neighboring sibling nodes when flooding nodes. In addition, if there is no room in adjacent sibling nodes, and node separation is inevitable, two nodes, one of adjacent sibling nodes and an overflowing node, are separated into three nodes. This ensures that the worst case index structure storage efficiency is more than 66.7% (2/3) and the average storage efficiency is more than 80%.

In addition, in order to design the index structure such that the area represented by the directory portion of the index structure represents the smallest portion of the data as much as possible, the present invention introduces the concept of minimum boundary interval to cover the data area covered by the index node as much as possible. Reduce search performance by increasing it.

Here, the minimum boundary interval is the shortest interval on the Hilbert curve that covers all areas of the node below.

2A and 2B show an index structure with and without an idea of the minimum boundary spacing.

As shown in FIG. 2A, the index node covers an area of 7 (= 4 + 3) in the index structure using the minimum boundary spacing, while the area covered by the index node in FIG. 2B does not use the concept of the minimum boundary spacing. Is 16 (= 8 + 8). The smaller the area of the region covered by the index node, the higher the efficiency of executing the region query and the maximum proximity query.

Therefore, it can be expected that the index structure of the present invention using the concept of the minimum boundary spacing is higher than the index structure without the concept of the minimum boundary spacing.

Hereinafter, an insertion method for generating an HG-tree index structure having the above characteristics, a deletion method for updating, and a method for searching (exact match search, region search, maximum proximity search) will be described.

Inserting the HG-tree of the new data object includes calculating a Hilbert value h of the data object o to be inserted and using this as a key to select a leaf node L into which the new data object is to be inserted; Inserting an object o into the selected leaf node L; When the leaf node L overflows, processing the overflow; Creating a set S comprising a leaf node L, an adjacent sibling node, and a new node when separation occurs in the overflow processing; A tree adjustment process of adjusting the minimum boundary region affected by the insertion of a new data object; As a result of tree adjustment, the route is separated by creating a new route and growing the height of the tree.

This will be described in detail with reference to FIGS. 3 to 6.

3 is a flowchart illustrating a process of inserting a new object into the HG-tree index structure of the present invention and performs object o at node N. FIG. 4 is a flowchart illustrating a process of selecting a leaf node into which a new object is to be inserted, and selecting a leaf node into which an object o having a Hilbert value h is to be inserted. 5 is a flowchart illustrating a flood processing process for flood generation when inserted.

FIG. 6 is a flowchart illustrating a tree adjustment process of adjusting an affected minimum boundary area after inserting a new object into a leaf node.

To insert a new data object o, calculate the Hilbert value h of the data object to be inserted (not described in the calculation process. Reference literature: ARButz, "Alternative Algorithm for Hibert's Space-Filling Curve", IEEE Transactions on Computers, April 1971 pp424-426), then call the leaf node selection (o, h) function (101).

The leaf node selection function then performs steps 108 through 112 of FIG. 4 to select and return the leaf node L into which the new data object o is to be inserted.

That is, it sets and initializes a root node to N (108), determines whether N is a leaf node (109), and if it is a leaf node, returns the node N (112), otherwise Hilbert Select the entry closest to the value h (110), set the node indicated by the selected entry to N (111), then repeat steps (109-111) until N is a leaf node, where N is a leaf node. If so, the leaf node selection is terminated by returning the node N.

When the leaf node is selected, the object o is inserted into the leaf node L, and then it is determined whether the leaf node L overflows (103). If the leaf node L overflows as a result of the determination, the flood handling (L, o) function is called to perform the flood occurrence processing.

As shown in FIG. 5, the overflow processing function distributes objects to sibling nodes when there is free space in the sibling node when overflow occurs. Otherwise, the nodes are separated, a new node is created, and the new node is returned.

Specifically, first set S to include all entries in sibling nodes adjacent to node N (113), add object o to S (114), and then among the siblings of N It is determined whether there is a free space (115). If there is a free space, the flooding process is terminated by distributing S to N and its sibling nodes (116).

However, as a result of the determination 115, if there is no free space, a new node NN is created and then a node s having a small area when combined with N is selected among two sibling nodes of N (117) (118), and N and S are combined. If we split the gap into three spaces, we find the two split points P1 and P2 that make the smallest area (119), and determine if the entry in S is less than P1, between P1 and P2. After the node is distributed to N, NN, and s depending on whether or not P2 is greater than P2, the flooding process is terminated by returning the newly generated node NN (120, 121).

At the time of insertion, when flooding occurs, after the processing is completed, a set S including leaf node L, an adjacent sibling node, and a new node NN when separation occurs in the flood processing process 113 to 121 is performed ( 105), call the tree adjustment (S) function to adjust the affected minimum boundary area.

The called tree adjustment (S) function adjusts the minimum boundary region from the leaf node to the root and proceeds from the leaf node to the route, adjusting the minimum boundary region of the nodes covering the nodes in the affected S upon insertion of a new object. The detailed process is as shown in FIG.

That is, after setting and initializing the node L to be updated to N (122), it is determined whether N is the root node (123). If N is the root node, the tree adjustment is terminated. Otherwise, a parent node of N is set in P (124), and it is determined whether N is separated (125).

If it is determined that N is not separated, the process proceeds to step 130, and if it is separated, a new node is set in NN (126), and it is determined whether there is free space in P. If there is free space, NN is inserted into P. (128) Otherwise, overflow processing (113 to 121) is performed to handle overflow (129).

Then, if P needs to be separated, a new node is set in the PP (130), Set to the set of parents of nodes in S, It adjusts the minimum boundary area of the entries in (131) and determines whether P is separated (132).

If P is separated, the above steps 123 to 131 are repeated, otherwise the tree adjustment is terminated.

When the tree is adjusted by adjusting the minimum boundary area to the root, when the root is separated by node spilt propagation, the insertion of the new data object o is terminated by creating a new root and growing the height of the tree. 107).

The deleting method for updating the HG-tree index structure includes: finding a leaf node L including the object o through exact match searching; Deleting the object o in the found leaf node; Determining whether the leaf node L causes an underflow due to the deletion, and processing the underflow; Creating a leaf node L, a set S including adjacent sibling nodes when an underflow occurs; A tree adaptation process of adjusting the minimum boundary region affected by the deletion; As a result of tree adaptation, if the root has only one child, the tree is reduced by one. The deletion method is similar to the insertion method. However, when the underflow occurs due to node separation, the data is borrowed from adjacent sibling nodes or adjacent siblings are deleted. Combining with nodes is different.

This will be described in detail with reference to FIGS. 7 to 9.

FIG. 7 is a flowchart illustrating a method of deleting an object in an HG-tree index structure. FIG. 8 is a flowchart illustrating an underflow process occurring when an object is deleted or a minimum boundary area is adjusted. FIG. 9 is a flowchart illustrating an object deletion. This is a flowchart showing the tree adaptation process of adjusting the minimum boundary area of the affected node.

First find the leaf node L containing the object o through the exact match search, delete the object o from L, then determine if the leaf node L causes the underflow, and if it does not cause the underflow, terminate the deletion and underflow If is generated, the underflow processing (L, o) function is called to process the occurrence of underflow (133 to 136).

The process of underflow collects all the entries in the sibling node adjacent to node N in S (140), deletes the object o in S (141), and then borrows data from the adjacent sibling node, as shown in FIG. The node determines whether an underflow occurs (142), and if an underflow does not occur, an entry is borrowed from an adjacent sibling node (143). However, if an underflow occurs, it combines two adjacent sibling nodes with N and then finds the separation position P which makes the area occupied the smallest when separating the gap between N and sibling nodes, and divides it into two nodes with the boundary. The flow processing ends (144, 145).

After the underflow processing is completed, a set S consisting of leaf nodes L and adjacent sibling nodes is formed, and then a tree adaptation (S) function is called (137) (138).

The called tree adaptation function adjusts the minimum boundary region from the leaf node to the root and adjusts the minimum boundary region from the leaf node to the root, adjusting the minimum boundary region of the nodes covering the nodes in the set S affected by the deletion of the object. The detailed procedure is as shown in FIG.

In other words, after setting and initializing the node L updated in N, it is determined whether N is the root, and if N is the root, the tree adaptation is terminated. Otherwise, P is given a parent node of N (146 to 148). Subsequently, it is determined whether N is combined with another node, and if N is combined with another node, it deletes N from P, and continuously determines whether P causes an underflow, and if an underflow occurs, an underflow process (P, N ) To handle the underflow (149-152).

after that Sets a set of parent nodes in S, After adjusting the minimum boundary area of entries in 153, P is set to N (154), and steps 147 to 154 are repeated until N is the root node.

After the tree adaptation process is performed, the minimum boundary region of the node affected by the deletion is adjusted to the root, and if the root has only one child, the deletion is terminated by reducing the height of the tree by one (139).

An Exact-Match Searching method for finding data with Hilbert value h in an HG-tree index structure is described.

In exact match search, the search starts from the root of the HG-tree and recursively searches along the branch containing the query value. When the leaf node is reached, it selects the data object with the same query value, that is, the Hilbert value h.

The HG-tree assigns sequential Hilbert values to all data objects and directory nodes, enabling binary search for internal node searches, which also speeds up internal node searches.

This will be described in detail with reference to FIG. 10.

First, the root node N is visited to determine whether N is a leaf node, and if there is a leaf node, an object having the Hilbert value h is output. If N is not a leaf node, the entry Ni containing the Hilbert value h is found ( 155-158).

Subsequently, it is determined whether Ni including h exists, and if Ni including h exists, the process proceeds to determining that N is a leaf node by providing Ni to N, otherwise the exact object search does not exist. It ends (159-161).

Range searching for the query region r in the HG-tree index structure recursively examines each branch starting at the root and overlapping the query region r, and outputs all data objects that overlap the query region r. A detailed description will be given with reference to FIG. 12.

FIG. 11 is a flowchart illustrating a method of searching a query region in an HG-tree index structure. FIG. 12 is a flowchart illustrating an overlapping process of searching whether a minimum bounding rectangle is included in the query region of FIG. 11.

To search the query region r, first visit the root node N and determine whether N is a leaf node. If N is a leaf node, all objects included in the query region r are output (162 to 164). However, if N is not a leaf node, set each entry in N to Ni, then overlap to check whether the minimum bounding square MBR (Ni) is included in the query region r, overlaps, or is outside (MBR (Ni), r) Call the function (165) (166).

Then, the overlap function outputs that the minimum boundary square I is included in the query region r, and does not overlap if I does not overlap r (172 to 175).

However, if I overlaps r, divides the minimum boundary of I into two minimum boundary intervals I1 and I2, dividing the minimum boundary square into two minimum boundary squares of the same size, and then overlaps again (minimum boundary squares I1 and r). And overlap (minimum bounding rectangles I2, r) are called (176) (177).

As a result of performing the two overlap functions, if both are included, the output is included. If the two overlapping functions are not included, the overlap process is outputted. Otherwise, the overlap process is terminated by outputting the overlap (178 to 182).

Overlap (MBR (Ni), r) Execution Result When the query area r is included in the minimum bounding square MBR (Ni), all objects included in Ni are outputted, and as a result of the overlap (MBR (Ni), r) query area r and When the minimum boundary square MBR (Ni) overlaps, the process proceeds to step 163 in which a child node of Ni is set to N and it is determined whether N is a leaf node (167 to 171).

As a result of performing the overlap (MBR (Ni), r), it is determined whether Ni is the last entry of N if the query region r is not included in or overlapped with the minimum bounding square MBR (Ni). The process proceeds to the process of setting each entry in N (165), and otherwise ends the region search (171).

The nearest neighbor searching method of the HG-tree index structure will be described with reference to FIGS. 13A and 13B.

13A and 13B are flowcharts illustrating a method of searching closest to a query position in an HG-tree index structure.

The maximum proximity search method checks downward from the top branches of the index tree given the location of the query. When checking at each node, calculate the closest distance δ _low from the query location to each entry in the node, and the closest distance δ _high to ensure the existence of data at the query location, and calculate the entries in each node in the order of δ _low . After sorting, a depth-first search is used to recursively examine the nearest branch, extracting k data that are close to a given query point.

Where N is the current node, P is the query point, Nearest is the list containing the k nearest neighbors (the nearest neighbor), and Branchlist is the list containing the branches that are not leaf nodes.

The current node N is visited (184), and it is determined whether N is a leaf node (184).

If N is a leaf node, determine the distance disti between query point P and object Ni for all entry Ni of N (185) (186), and set the kth closest distance between N and P to Nearest [k] .dist. Set the kth closest object between N and P in Nearest [k] .obj (187), then disti in Nearest [k] .dist if Distance disti is less than Nearest [k] .dist, and Nearest [k] Specify Ni in .obj, then rearrange the entries of the nearest neighbors in chronological order and repeat this process until the last entry (188-191).

However, if the current node N is not a leaf node, it calculates the closest distance between query points P and Ni for all entries Ni of N, sets δ _lowi, and calculates the closest distance to ensure the existence of objects between P and Ni. After setting δ _high , δ _high , δ _lowi and Ni are stored in the branchlist (192 to 195).

It then sorts the contents of the Branchlist according to δ _low , and then removes those in the Branchlist that are farther than those in the nearest neighbor (196) (197).

Recursively call the closest search (Ei's child nodes, P, Nearest) for all entries Ei in the branchlist to remove all entries Ei in the branchlist by removing the distant ones from the branchlist. The maximum proximity search is terminated by arranging (198 to 201).

As described above, the HG-tree index structure of the present invention and its insertion, deletion, and retrieval method are a database for multimedia data or geographic information data having a complex structure of data characteristics and represented in a multidimensional space instead of one dimension. It can be effectively used in the system, and especially has high search performance when searching for multimedia data by contents.

Claims (11)

Use Hilbert curves to map all locations in n-dimensional space to locations on a one-dimensional line to increase storage efficiency, and to ensure that the area represented by the directory portion of the index structure is as minimal as possible in the realm of data occupied. Introducing the concept of spacing to reduce the area of data covered by index nodes as much as possible, using the HG-tree index structure to improve search performance, calculating the Hilbert value h of the data object o to be inserted, and using this as the key selecting a leaf node o into which to insert o; Inserting an object o into the selected leaf node L; When the leaf node L overflows, processing the overflow; Creating a set S comprising a leaf node L, an adjacent sibling node, and a new node when separation occurs in the overflow processing; A tree adjustment process of adjusting the minimum boundary region affected by the insertion of a new data object; Inserting a method for generating an HG-tree index structure, comprising the step of increasing the height of the tree by creating a new route when splitting the route as a result of tree adjustment. The method of claim 1, wherein the selecting of the leaf node L into which the new data object o is to be inserted comprises: initializing N as a root node; Determining whether the repeated N is a leaf node until N is a leaf node; if the determination result is a leaf node, returning the node N; otherwise, selecting an entry closest to the Hilbert value h; Inserting a node pointed to by the entry, the method comprising: creating an HG-tree index structure. 2. The method of claim 1, wherein the processing of flood occurrence of leaf node L comprises: initializing by setting a set comprising all entries in sibling nodes adjacent to node N in S; Adding an object o to S; Determining whether there is a free space among two sibling nodes of N, distributing S to N and its sibling nodes if there is free space, and generating a new node NN if there is no free space; Selecting a node s whose area occupied when combined with N is small among two sibling nodes of N; Obtaining two separation points P1 and P2 which make the area occupied the smallest when occupying the space into three in the space where N and S are combined; Distributing the node to N, NN, s according to whether an entry in S is less than P1, between P1 and P2, or greater than P2; And returning a newly created node NN. The method of claim 1, wherein the tree adjustment process of adjusting the minimum boundary region affected by the insertion of the new object o comprises: initializing and setting a node L to be updated to N; Determining whether N is the root node or whether N is the root node which is repeated until N's parent node is separated, and if N is the root node, terminates the tree adjustment; otherwise, sets N's parent node to P; and ; Judging whether N has been separated, and if so, setting a new node at NN; Determining whether there is free space in P if N is not separated, and inserting NN in P if free space exists; otherwise performing overflow processing; Setting a new node in the PP if P needs to be separated; Sets a set of parents of nodes in S, Adjusting a corresponding minimum boundary area of entries in the document; And determining whether or not P has been separated, and if so, terminating tree adjustment. Use Hilbert curves to map all locations in n-dimensional space to locations on a one-dimensional line to increase storage efficiency, and to ensure that the area represented by the directory portion of the index structure is as minimal as possible in the realm of data occupied. Introducing a concept of spacing to reduce the data area covered by the index node as much as possible, using the HG-tree index structure to improve the search performance, and finding a leaf node L including the object o through an exact match search; Deleting the object o in the found leaf node; Determining whether the leaf node L causes the underflow due to the deletion, and processing the underflow; Creating a set S comprising leaf nodes L and adjacent sibling nodes when an underflow occurs; A tree adaptation process of adjusting the minimum boundary region affected by the deletion; A method for deleting an HG-tree index structure, comprising reducing the height of the tree by one if the root has only one child as a result of tree adaptation. 7. The method of claim 6, wherein processing the underflow comprises: gathering all entries in sibling nodes adjacent to node N in S as a set S; Deleting the object o from S; Determining whether the node causes an underflow when borrowing data from an adjacent sibling node; Borrowing an entry from an adjacent sibling node if the underflow does not occur as a result of the determination; Combining an adjacent sibling node with N when an underflow occurs, and then finding a separation position P that makes the area occupied the smallest when the interval between N and sibling nodes is separated; And dividing the node into two nodes with P as a boundary. 7. The method of claim 6, wherein the tree adaptation process of adjusting the minimum boundary region affected by the deletion comprises: initializing and setting a node L updated to N; Determining whether repeated N is the root until N is the root node, and ending the tree adaptation if N is the root; otherwise, setting the parent node of N to P; Determining whether N is associated with another node, and if N is associated with another node, deleting N from P; Determining whether P causes an underflow, and if the underflow occurs, processing the underflow; Sets a set of parent nodes in S, Adjusting a corresponding minimum boundary area of entries in the document; And setting P to N. 4. The method of claim 1, wherein the method comprises: setting P to N. Use Hilbert curves to map all locations in n-dimensional space to locations on a one-dimensional line to increase storage efficiency, and to ensure that the area represented by the directory portion of the index structure is as minimal as possible in the realm of data occupied. Introducing a spacing concept to reduce the data area covered by the index node as much as possible, thereby using a HG-tree index structure that improves search performance, and visiting the root node N; Determining whether N is a leaf node; If the determination result is a leaf node, outputting an object having a Hilbert value h, and otherwise finding an entry Ni including the Hilbert value h; determining whether Ni including h exists; If the determination result includes Ni that includes h, the process proceeds to setting Ni to N and determining whether N is a leaf node, or otherwise ending the exact match search since the corresponding object does not exist. Exact match search method of HG-tree index structure. Use Hilbert curves to map all locations in n-dimensional space to locations on a one-dimensional line to increase storage efficiency, and to ensure that the area represented by the directory portion of the index structure is as minimal as possible in the realm of data occupied. Introducing a spacing concept to reduce the data area covered by the index node as much as possible, thereby using a HG-tree index structure that improves search performance, and visiting the root node N; Determining whether N is a leaf node; If N is a leaf node, outputting all objects included in the query region r and ending the region search; Setting each entry in N to N if N is not a leaf node; An overlapping process for checking whether the minimum bounding rectangle I is included in, overlapping, or outside the query region r; Outputting all objects included in Ni when the query region r is included in the minimum bounding square MBR (Ni) according to the result of the process; When the query region r and the minimum boundary square MBR (Ni) overlap as a result of performing the overlap test, shifting to setting Ni to N and determining whether to be a N-day leaf node; Determining whether Ni is the last entry of N, and shifting to setting each entry in N in Ni if it is not the last entry. 11. The method of claim 10, wherein the overlapping process of checking whether the minimum bounding rectangle I is included in, overlapping, or outside the query region r comprises: outputting the minimum bounding rectangle I when the minimum bounding square I is included in the query region r; Outputting not overlapping if I does not overlap with r; Dividing the minimum boundary interval of I into two minimum boundary intervals I1 and I2 where I and r overlap the minimum boundary square into two minimum boundary squares of the same size; Calling the overlap (minimum boundary rectangle I1, r) and the overlap (minimum boundary rectangle I2, r); Outputting both of the results of the two overlapping calls if they are included; Outputting a non-overlapping if both of the results of the two overlapping calls do not overlap; otherwise, outputting the overlap. Use Hilbert curves to map all locations in n-dimensional space to locations on a one-dimensional line to increase storage efficiency, and to ensure that the area represented by the directory portion of the index structure is as minimal as possible in the realm of data occupied. Introducing a spacing concept to reduce the data area covered by the index node as much as possible, using the HG-tree index structure to improve the search performance, and visiting the node N to determine whether it is a leaf node; If N is a leaf node, the distance disti of the query point P and the object Ni is determined for all entries Ni of N, and the kth closest distance between N and P to Nearest [k] .dist is set to Nearest [k] .obj. After setting the kth closest object between N and P, if the distance disti is less than Nearest [k] .dist, specify disti in Nearest [k] .dist and Ni for Nearest [k] .obj. Rearranging entries of maximum neighbors; If the current node N is not a leaf node, for all entries Ni of N, the closest distance δ _lowi between the query points P and Ni is calculated, and the closest distance δ _high that guarantees the existence of the object between P and Ni, After storing δ _high , δ _lowi, and Ni, sort the contents of the Branchlist according to δ _low , and then remove any of those in the Branchlist that are farther than those in the nearest neighbor, and remove all entries Ei in the Branchlist. And recursively calling the maximum proximity search (child node, P, Nearest) of Ei, and removing all the distances from those in Branchlist to arrange all entries Ei in Branchlist. Maximum proximity search of HG-tree index structure.