JP2008287533A - Longest conformity/shortest conformity retrieval method for coupled node tree, and program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a method for the longest comformity/shortest comformity retrieval with a coupled node tree as the object of retrieval. <P>SOLUTION: A coupled node tree is comprised of: a root node; a branch node disposed between neighboring memory areas; and a pair of leaf nodes or branch nodes or a pair of a leaf node and a branch node. The branch node includes information indicating the discriminating bit position of a retrieval key and the position of one node of the pair of nodes to be linked. The leaf node includes an index key comprised of a retrieval subject bit sequence. The coupled node tree is retrieved by using the longest comformity/shortest comformity retrieval key, and the longest comformity/shortest comformity node is determined based on the comparison of the difference bit position of the index key of the retrieval result and the longest comformity/shortest comformity retrieval key and the discriminating bit position of the branch node on a retrieval path from the route node stored upon retrieval. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a search method for searching for a desired bit string from a set of bit strings using a tree-like data structure for storing bit strings, and in particular, a coupled node tree proposed by the present applicant in Japanese Patent Application No. 2006-187827. The longest match search / shortest match search method and its program.

  In recent years, with the progress of informatization of society, large-scale databases are being used in various places. In order to search for a record from such a large database, it is usual to search for an item in the record associated with the stored address of each record using an index key to find a desired record. A character string in full-text search can also be regarded as a document index key.

Since these index keys are expressed by bit strings, it can be said that a database search is reduced to a bit string search.
In order to search the bit string at high speed, various data structures for storing the bit string have been conventionally devised. As one of such things, a tree structure called a Patricia tree is known.

  FIG. 13 shows an example of a Patricia tree used in the above-described conventional search process. The Patricia tree node includes an index key, a check bit position of the search key, and left and right link pointers. Although not explicitly shown, it goes without saying that the node includes information for accessing the record corresponding to the index key.

  In the example of FIG. 13, the node 1750a holding the index key “100010” is the root node, and its check bit position 1730a is 0. A node 1750b is connected to the left link 1740a of the node 1750a, and a node 1750f is connected to the right link 1741a.

  The index key held by the node 1750b is “010011”, and the check bit position 1730b is 1. A node 1750c is connected to the left link 1740b of the node 1750b, and a node 1750d is connected to the right link 1741b. The index key held by the node 1750c is “000111”, and the check bit position is 3. The index key held by the node 1750d is “011010”, and the check bit position is 2.

  The portion connected by a solid line from the node 1750c indicates the left and right link pointers of the node 1750c, and the left pointer 1740c not connected by the dotted line indicates that the column is blank. The connection destination of the dotted line of the right pointer 1741c connected to the dotted line represents the address indicated by the pointer. In this case, the right pointer 1741c specifies the node 1750c.

  The right pointer 1741d of the node 1750d points to the node 1750d itself, and the node 1750e is connected to the left link 1740d. The index key held by the node 1750e is “010010”, and the check bit position 1730e is 5. The left pointer 1740e of the node 1750e points to the node 1750b, and the right pointer 1741e points to the node 1750e.

  Further, the index key held by the node 1750f is “101101”, and the check bit position 1730f is 2. A node 1750g is connected to the left link 1740f of the node 1750f, and a node 1750h is connected to the right link 1741f.

  The index key held by the node 1750g is “1000011”, and the check bit position 1730g is 5. The left pointer 1740g of the node 1750g points to the node 1750a, and the right pointer 1741g points to the node 1750g.

  The index key held by the node 1750h is “101100”, and the check bit position 1730h is 3. The left pointer 1740h of the node 1750h points to the node 1750f, and the right pointer 1741h points to the node 1750h.

In the example of FIG. 13, the check bit position of each node is configured to increase as the tree descends from the root node 1750a.
When performing a search with a certain search key, the check bit position of the search key held in each node is sequentially checked from the root node, and it is determined whether the bit value of the check bit position is 1 or 0, If it is 1, follow the right link, if it is 0, follow the left link. If the check bit position of the link destination node is not larger than the check bit position of the link source node, that is, if the link destination returns upward rather than downward (the reverse link indicated by the dotted line in FIG. The index key of the link destination node and the search key are compared. As a result of the comparison, it is guaranteed that the search is successful if they are equal and the search is unsuccessful if they are not equal.

  As described above, search processing using the Patricia tree has advantages such as being able to search only by checking the necessary bits and comparing the entire key only once, but there are always two links from each node. Increase in storage capacity due to the presence of the data, complicating judgment processing due to the presence of a back link, difficulty in data maintenance such as search processing delay and addition / deletion by comparing with an index key for the first time by returning by a back link, etc. There are disadvantages.

  As a technique for overcoming the disadvantages of these Patricia trees, for example, there is a technique disclosed in Patent Document 1 below. In the Patricia tree described in the following Patent Document 1, the lower left and right nodes are stored in a continuous area, thereby reducing the storage capacity of the pointer, and a bit indicating whether or not the next link is a back link Is provided at each node to reduce the back link determination process.

  However, in the one disclosed in Patent Document 1 below, one node always occupies the index key area and the pointer area, and the lower left and right nodes are stored in a continuous area, and one pointer is used. Therefore, for example, it is necessary to allocate a storage area having the same capacity as the node to the left pointer 1740c and the right pointer 1741h, which are the lowermost parts of the Patricia tree shown in FIG. It's not big. In addition, the problem of delay in search processing due to the back link and the difficulty of processing such as additional deletion have not been improved.

In order to solve the above-described problems in the conventional search method, the present applicant has disclosed in Japanese Patent Application No. 2006-187827 that the root node, the branch node arranged in the adjacent storage area, the leaf node, the branch nodes, or the leaf. A tree used for bit string search consisting of node pairs between nodes, where the root node is a node representing the starting point of the tree, and when there is one node in the tree, it is a leaf node, and when there are two or more nodes in the tree Is a branch node, and the branch node includes a discrimination bit position of a search key for performing a bit string search and position information indicating a position of one node of a link destination node pair, and the leaf node is obtained from a bit string to be searched. A bit string search using a coupled node tree with an index key It was.

  In the above application, a basic method using a coupled node tree, such as a method for generating a coupled node tree from a given set of index keys and a method for retrieving a single index key from the coupled node tree. A search technique is shown.

  In the search for bit strings, there are various search requests such as obtaining a minimum value, a maximum value, and obtaining a value within a certain range. In view of this, the present applicant proposed in Japanese Patent Application No. 2006-293619 a method for obtaining the maximum value / minimum value of an index key included in an arbitrary subtree of a coupled node tree.

  Furthermore, the bit string search includes a search for a value that at least partially matches the search key, in addition to a search for a value that completely matches the search key. An example is the longest match (or shortest match) search in which one or more bits from the most significant bit match the search key and the matching range tries to search for an index key that is as large (or as small) as possible.

  The longest match search can be used for searching a routing table or for searching for a broadcast address when data is broadcast to a plurality of addresses having the same high-order bit. The shortest match search can be used for a character string search using a regular expression, a search target narrowing down, or the like. Therefore, it is desired to speed up these searches and improve the processing efficiency in various application fields.

Patent Document 2 describes a technique for speeding up the longest match search using a Patricia tree. However, since the coupled node tree is a new data structure invented by the present applicant, a conventional longest match search method is disclosed. Cannot be used.
JP 2001-357070 A Japanese Patent Laid-Open No. 2003-224581

  An object of the present invention is to provide a method and a program for performing a longest match / shortest match search using a coupled node tree as a search target.

  The coupled node tree to be searched by the present invention is a tree used for a bit string search including a root node, a branch node arranged in an adjacent storage area and a leaf node or a node pair between branch nodes or a leaf node. is there. The root node is a node that represents the starting point of a tree. When there is one node in the tree, the root node is the leaf node, and when there are two or more nodes in the tree, the root node is the branch node. The branch node includes position information indicating a discrimination bit position of a search key for performing a bit string search and a representative node that is one node of a link destination node pair, and the leaf node is an index key including a bit string to be searched including.

The coupled node tree is a representative node of a link destination node pair according to a bit value of a search key of a discrimination bit position included in the branch node, with an arbitrary node of the tree as a search start node. Alternatively, by sequentially linking to a node arranged in a storage area adjacent to the leaf node, the index key stored in the leaf node is used as an index key of the tree having the search start node as a root node. A search result key that is a result of a search by the search key of an arbitrary partial tree is configured.

  In the longest match search method using the coupled node tree according to the present invention, the root node of the coupled node tree is used as the search start node, and the specified longest match search key is used as the search key. A search step of acquiring the search result key by performing the search while storing the path of the search, and comparing the bit string of the longest match search key and the search result key, and out of the positions of the mismatch bit where the bit values do not match A difference bit position acquisition step for acquiring a difference bit position that is the highest position, and a longest match node that sets a longest matching node with reference to the stored path when the difference bit position is a position other than the highest position of a bit string A matching node setting step, wherein the root node is the leaf node or the root node is If the discrimination bit position of the root node is a position lower than the difference bit position, the root node is set as the longest match node; otherwise, it is a node on the path. The branch node or the leaf node stored in the search step next to the branch node having the lowest discrimination bit position among the branch nodes having the discrimination bit position higher than the difference bit position. And a longest matching node setting step for setting as the longest matching node.

  The shortest match search method using the coupled node tree according to the present invention includes a search step and a difference bit position acquisition step similar to the above except that a shortest match search key is used instead of the longest match search key, and the difference bit A shortest match node setting step for setting a shortest match node with reference to the stored route when the position is a position other than the highest bit of the bit string, wherein the route is a link between the root node and the root node; A first node that is one of the branch nodes of the previous node pair, and when the discrimination bit position of the root node is higher than the difference bit position, the link of the first node The second node that is the node that is not stored in the route of the previous node pair is set as the shortest matching node. Comprising the shortest match node setting step that, a.

  According to the present invention, it is possible to perform a longest match / shortest match search using a coupled node tree as a search target. Therefore, the coupled node tree can be used in various application fields that require the longest match / shortest match search. Since the coupled node tree is configured to speed up the search, the longest match / shortest match search using the coupled node tree is fast. Therefore, the processing speed of the longest match / shortest match search in various application fields can be increased.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
First, an example of storing a coupled node tree in an array will be described with respect to the coupled node tree proposed by the present applicant in the above-mentioned application and serving as a premise of the present invention. The address information of the storage device can be used as the data indicating the link destination position held by the branch node, but it consists of an array element that can store the larger storage capacity of the area occupied by the branch node or leaf node. By using the array, the position of the node can be represented by an array number, and the amount of information on the position information can be reduced.

FIG. 1 is a diagram for explaining a configuration example of a coupled node tree stored in an array.
Referring to FIG. 1, the node 101 is arranged in the array element of the array element number 10 in the array 100. The node 101 has a node type 102, a discrimination bit position 103, and a representative node number 10
4 is configured. The node type 102 is 0, indicating that the node 101 is a branch node. 1 is stored in the discrimination bit position 103. The representative node number 104 stores the array element number 20 of the representative node of the link destination node pair. Hereinafter, for simplification of the notation, the array element number stored in the representative node number may be referred to as a representative node number. Further, the array element number stored in the representative node number may be represented by a code attached to the node or a code attached to the node pair.

  The array element with the array element number 20 stores the node [0] 112 that is the representative node of the node pair 111. Then, node [1] 113 paired with the representative node is stored in the next adjacent array element (array number 20 + 1). 0 is stored in the node type 114 of the node [0] 112, 3 is stored in the discrimination bit position 115, and 30 is stored in the representative node number 116. Further, 1 is stored in the node type 117 of the node [1] 113, indicating that the node [1] 113 is a leaf node. The index key 118 stores “0001”. As described above for the Patricia tree, it is natural that the leaf node includes information for accessing the record corresponding to the index key, but the description is omitted.

  A representative node may be represented by a node [0] and a node paired therewith may be represented by a node [1]. In addition, a node stored in an array element having a certain array number may be referred to as a node having the array number, and an array number of the array element in which the node is stored may be referred to as a node array number.

The contents of the node pair 121 composed of the node 122 and the node 123 stored in the array elements of the array element numbers 30 and 31 are omitted.
The 0 or 1 added to the array elements stored in the node [0] 112, the node [1] 113, the node 122, and the node 123 are linked to either node of the node pair when searching with the search key. It shows what to do. The search key bit value 0 or 1 at the discrimination bit position of the preceding branch node is linked to the node of the array element number obtained by adding the representative node number.

  Therefore, by adding the bit value of the discrimination bit position of the search key to the representative node number of the preceding branch node, the array element number of the array element storing the link destination node can be obtained.

In the above example, the representative node number is the smaller of the array element numbers where the node pairs are arranged. However, it is obvious that the larger one can be adopted.
FIG. 2 is a diagram conceptually showing a tree structure of a coupled node tree. The 6-bit index key shown is the same as that of the Patricia tree illustrated in FIG.

A reference numeral 210a indicates a root node. In the illustrated example, the root node 210a is a representative node of the node pair 201a arranged at the array element number 220.
As a tree structure, a note pair 201b is arranged below the root node 210a, a node pair 201c and a node pair 201f are arranged below it, and a node pair 201h and a node pair 201g are arranged below the node pair 201f. A node pair 201d is disposed below the node pair 201c, and a node pair 201e is disposed below the node pair 201d.

  The code of 0 or 1 added before each node is the same as the code assigned before the array element described in FIG. The tree is traversed according to the bit value of the discrimination bit position of the search key, and the leaf node to be searched is found.

  In the illustrated example, the node type 260a of the root node 210a is 0, indicating that it is a branch node, and the discrimination bit position 230a indicates 0. The representative node number is 220a, which is the array element number of the array element stored in the representative node 210b of the node pair 201b.

  The node pair 201b is composed of nodes 210b and 211b, and the node types 260b and 261b are both 0, indicating that they are branch nodes. 1 is stored in the discrimination bit position 230b of the node 210b, and the array element number 220b of the array element stored in the representative node 210c of the node pair 201c is stored in the link representative node number.

  Since 1 is stored in the node type 260c of the node 210c, this node is a leaf node and therefore includes the index key 250c. “000111” is stored in the index key 250c. On the other hand, the node type 261c of the node 211c is 0, the discrimination bit position 231c is 2, and the array element number 221c of the array element stored in the representative node 210d of the node pair 201d is stored in the representative node number.

  The node type 260d of the node 210d is 0, the discrimination bit position 230d is 5, and the array number 220d of the array element in which the representative node 210e of the node pair 201e is stored is stored in the representative node number. The node type 261d of the node 211d paired with the node 210d is 1, and “011010” is stored in the index key 251d.

  The node types 260e and 261e of the nodes 210e and 211e of the node pair 201e are both 1, indicating that both are leaf nodes. “010010” and “010011” are stored as index keys in the index keys 250e and 251e, respectively. Has been.

  2 is stored in the discrimination bit position 231b of the node 211b which is the other node of the node pair 201b, and the array element number 221b of the array element in which the representative node 210f of the node pair 201f is stored is stored in the representative node number of the link destination. Stored.

  The node types 260f and 261f of the nodes 210f and 211f of the node pair 201f are both 0, and both are branch nodes. 5 and 3 are stored in the discrimination bit positions 230f and 231f, respectively. The representative node number of the node 210f stores the array element number 220f of the array element in which the representative node 210g of the node pair 201g is stored, and the representative node number of the node 211f contains the node [0] 210h that is the representative node of the node pair 201h. The array element number 221f of the stored array element is stored.

  The node types 260g and 261g of the nodes 210g and 211g of the node pair 201g are both 1, indicating that both are leaf nodes, and “100010” and “1000011” are stored in the respective index keys 250g and 251g. .

  Similarly, the node type 260h and 261h of the node [0] 210h, which is the representative node of the node pair 201h, and the node [1] 211h that is paired with the node [0] 210h are both 1, indicating that both are leaf nodes. In “250h” and “251h”, “101011” and “101100” are stored.

The flow of processing for searching for the index key “100010” from the above tree will be briefly described below. The discrimination bit positions are 0, 1, 2,... From the left.
First, processing is started from the root node 210a using the bit string “100010” as a search key. Since the discrimination bit position 230a of the root node 210a is 0, it is 1 when the bit value of the discrimination bit position of the search key “100010” is 0 is seen. Therefore, the node 211b stored in the array element having the array element number obtained by adding 1 to the array element number 220a storing the representative node number is linked. Since 2 is stored in the discrimination bit position 231b of the node 211b, the discrimination bit position of the search key “100010” is 0 when the bit value of 2 is viewed, and therefore the array number 221b in which the representative node number is stored is Link to the node 210f stored in the array element.

  Since 5 is stored in the discrimination bit position 230f of the node 210f, the discrimination bit position of the search key “100010” is 0 when the bit value of 5 is seen, and therefore the array number 220f in which the representative node number is stored is Link to the node 210g stored in the array element.

  Since the node type 260g of the node 210g is 1, indicating that it is a leaf node, when the index key 250g is read and compared with the search key, both are “100010” and match. In this way, a search using a coupled node tree is performed.

Next, the meaning of the configuration of the coupled node tree will be described with reference to FIG.
The configuration of a coupled node tree is defined by a set of index keys. In the example of FIG. 2, the discrimination bit position of the root node 210a is 0 because the index key exemplified in FIG. The index key group whose 0th bit is 0 is classified under the node 210b, and the index key group whose 0th bit is 1 is classified under the node 211b.

  The discrimination bit position of the node 211b is 2 because the 0th bit stored in the nodes 211h, 210h, 211g and 210g is all equal to 0 in the 1st bit of the index key, and is different for the first time in the 2nd bit. This reflects the nature of the set of index keys.

Hereinafter, as in the case of the 0th bit, a case where the second bit is 1 is classified on the node 211f side, and a case where the second bit is 0 is classified on the node 210f side.
Since there are different index keys whose second bit is 1, the third bit is different, so 3 is stored in the discrimination bit position of the node 211f, and in the index key whose second bit is 0, the third bit is also the fourth bit. Since the fifth bit is equally different, 5 is stored in the discrimination bit position of the node 210f.

  In the link destination of the node 211f, since there is only one each of which the first bit is 1 and 0, the nodes 210h and 211h are leaf nodes, and “101011” and “101100” are assigned to the index keys 250h and 251h, respectively. "Is stored.

  Even if “101101” or “101110” is included in the set of index keys instead of “101100”, since the third bit is equal to “101100”, only the index key stored in the node 211h changes. Thus, the tree structure itself does not change. However, if “101101” is included in addition to “101100”, the node 211h becomes a branch node, and its discrimination bit position is 5. If the index key to be added is “101110”, the discrimination bit position is 4.

As described above, the coupled node tree structure is determined by the bit value of each bit position of each index key included in the set of index keys.
Furthermore, since the node branches to a node having a bit value “1” and a node having a bit value “0” for each bit position having a different bit value, the node [1] side and the depth of the tree When the leaf nodes are traced with priority given to the direction, the index keys stored in them are “101100” of the index key 251h of the node 211h, “101011” of the index key 250h of the node 210h,. The key 250c is “000111” and is sorted in descending order.

That is, in the coupled node tree, the index keys are sorted and arranged on the tree.
When searching with the search key, the index key follows the route arranged on the coupled node tree. For example, if the search key is “101100”, the node 211h can be reached. Further, as can be imagined from the above description, even when “101101” or “101110” is used as a search key, it is found that the search has failed by reaching the node 211h and comparing with the index key 251h.

  For example, even when a search is performed with “100100”, the third and fourth bits of the search key are not used in the link paths of the nodes 210a, 211b, and 210f, and the fifth bit of “100100” is 0. The node 210g is reached in the same manner as when searching for “100010”. In this way, branching is performed using the discrimination bit position corresponding to the bit configuration of the index key stored in the coupled node tree.

FIG. 3 is a diagram for explaining a hardware configuration example for carrying out the present invention.
Search processing and data maintenance by the search device of the present invention are performed by the data processing device 301 including at least the central processing unit 302 and the cache memory 303 using the data storage device 308. A data storage device 308 having a search path stack 310 for storing an array 309 in which a coupled node tree is arranged and an array element number in which a node to be traced is stored is a main storage device 305 or an external storage device 306. It is also possible to use a device that can be implemented or that is located remotely connected via the communication device 307. The array 100 in FIG. 1 is an example of the array 309.

  In the example of FIG. 3, the main storage device 305, the external storage device 306, and the communication device 307 are connected to the data processing device 301 by a single bus 304, but the connection method is not limited to this. Further, the main storage device 305 can be in the data processing device 301, and the search path stack 310 can be realized as hardware in the central processing unit 302. Alternatively, the array 309 has an external storage device 306, a search path stack 310 in the main storage device 305, etc. It is clear that the hardware configuration can be appropriately selected according to the usable hardware environment, the size of the index key set, etc. It is.

Further, although not particularly illustrated, it is natural that a temporary storage device corresponding to each process is used in order to use various values obtained during the process in a later process.
Next, in the above-mentioned application, the basic search process using the coupled node tree proposed by the applicant, the insertion / deletion process in the coupled node tree, and the maximum value of the index key included in the coupled node tree / A part of application processing such as processing for obtaining the minimum value will be introduced to the extent necessary for understanding the present invention by referring to FIGS.

FIG. 4 is a flowchart showing the basic operation of the bit string search proposed in the above Japanese Patent Application No. 2006-293619 filed by the present applicant.
First, in step S401, the array element number of the search start node is acquired. The array element corresponding to the acquired array number stores arbitrary nodes constituting the coupled node tree. The designation of the search start node is performed in various application searches described later.

  Next, in step S402, the obtained array element number is stored in the search path stack 310, and in step S403, the array element corresponding to the array element number is read as a node to be referred to. In step S404, the node type is extracted from the read node, and in step S405, it is determined whether or not the node type is a branch node.

  If it is determined in step S405 that the read node is a branch node, the process proceeds to step S406, where information on the discrimination bit position is extracted from the node, and in step S407, a bit value corresponding to the extracted discrimination bit position is obtained. Retrieve from search key. In step S408, the representative node number is extracted from the node. In step S409, the bit value extracted from the search key and the representative node number are added, and the process returns to step S402 as a new array number.

  Thereafter, the processing from step S402 to step S409 is repeated until it is determined that the node is a leaf node in step S405 and the process proceeds to step S410. In step S410, the index key is extracted from the leaf node, and the process ends.

  As above, the coupled node tree that is the basis of the present invention and the basic operation of the bit string search have been described in detail. The coupled node tree generation process is not particularly shown, but as described in Japanese Patent Application No. 2006-187827, which is the previous application by the present applicant, when there is a set of bit strings, an arbitrary one is generated therefrom. This is possible by repeating the process of sequentially taking out bit strings and inserting them as index keys.

  As described above, the index key values stored in the coupled node tree are sorted on the tree in descending order by following the depth direction of the tree with the node [1] side. In the index key insertion process, the corresponding leaf node is searched from the coupled node tree using the index key to be inserted as a search key, and the branch node and the leaf node of the link path that has reached the leaf node are stored. The array element array numbers are sequentially stored in the stack, the size key and bit string comparison are performed between the search key and the index key included in the corresponding leaf node, and the first bit position and the above bit positions that are different in the bit string comparison The relative positional relationship with the discrimination bit position of the branch node stored in the stack The insertion position of the node pair consisting of the leaf node including the index key to be inserted and the other node is determined, and the leaf node including the index key to be inserted according to the size relationship is determined as either of the nodes of the inserted node pair. This can be done by deciding whether or not to do so.

  FIG. 5 is a flowchart showing a process for obtaining the minimum value of the index key stored in the coupled node tree (including the partial tree) proposed in the above-mentioned Japanese Patent Application No. 2006-293619 filed by the present applicant. The processing for obtaining the minimum value of the index key from the arrangement of the index key on the tree as described above corresponds to tracing the node [0] from the search start node to the leaf node on the tree.

  First, the processing from the acquisition of the array element number of the search start node in step S501 to the determination of the node type in step S505 is the same as the processing in steps S401 to S405 in FIG.

If the node type is determined to be a branch node in the determination of the node type in step S505, the process proceeds to step S506, the representative node number of the array is extracted from the node, and the value “0” is added to the extracted representative node number in step S507. Then, the result is set as a new array number, and the process returns to step S502. Thereafter, the processing from step S502 to step S507 is repeated until it is determined in step S505 that the node is a leaf node. In step S508, the index key is extracted from the leaf node, and the processing is terminated.

  In the process shown in FIG. 5 above, in order to follow the node [0], “0” is uniformly added to the representative node number. That is, according to the processing of FIG. 5, the link destination node is always node [0] of the node pair, and branches to a node storing a smaller index key. As a result, the minimum index key of the coupled node tree whose tree structure is a permutation structure as described above can be extracted.

  Naturally, the maximum value of the index key stored in the coupled node tree (including the partial tree) can be obtained by a method similar to FIG. Specifically, if the process of FIG. 5 is changed to add “1” instead of “0” in step S507, the maximum value of the index key can be obtained. This is because, by this change, the node pair represented by the representative node number is always linked to the node [1], and the hierarchy of the tree structure can be sequentially followed up to the leaf node.

  As shown in FIGS. 4 and 5, when executing a basic operation for searching for an index key that matches the search key or a search process for the minimum / maximum value of the index key, The array number is stored sequentially.

  In the above-described index key minimum / maximum value search processing with reference to FIG. 5, the coupled node tree has been described as being stored in the array. However, the coupled node tree is stored in the array. It is not essential, and only the representative node of the two nodes constituting the node pair or only the nodes arranged in the storage area adjacent to the representative node are linked to reach the leaf node to reach the minimum / maximum index key. It is clear that the search can be performed.

The technology that is the premise of the longest match / shortest match search of the coupled node tree has been described above. If necessary, refer to the description of the above patent application and the drawings.
Hereinafter, a longest match / shortest match search of a coupled node tree according to the present invention will be described. First, terms used in the following embodiment and preconditions in the following embodiment will be described.

(A) The longest match search is a process of searching for an index key with the lowest difference bit position among index keys that partially match a longest match search key that is a designated search key. Such an index key is defined as an “index key that satisfies the longest matching condition”. There may be no index key that satisfies the longest matching condition, or there may be one or more index keys. Note that the difference bit position represents the highest position among non-matching bits whose bit values do not match when two bit strings are compared.

(B) The shortest match search is a process of preferentially searching for an index key having a higher difference bit position among index keys that partially match a shortest match search key that is a designated search key. The details of the definition of the shortest match may vary depending on the embodiment. In the following embodiment, the shortest match search method will be described in detail by defining the shortest match as follows.

The bit value up to the discrimination bit position of the root node is exactly the same as the shortest match search key, but the bit value after the discrimination bit position of the root node is the index key that has a bit that does not match the shortest match search key. It is defined as an index key that satisfies the matching condition. There may be no index key that satisfies the shortest matching condition, or there may be one or more index keys.

Next, a specific method of the longest match search of the coupled node tree will be described with reference to FIGS.
FIG. 6 is a flowchart of the longest match search process according to an embodiment of the present invention. The outline of the processing in FIG. 6 is that the longest matching node is acquired in steps S601 to S606, and one index key is acquired from the subtree having the longest matching node as the root node in steps S607 to S608. . When the index keys of all leaf nodes included in a subtree satisfy the longest match condition, the root node of the subtree is defined as the longest match node. Therefore, the index key acquired in steps S607 to S608 satisfies the longest match condition. More specifically, the process of FIG. 6 is as follows.

The longest match search key specified in step S601 is set as a search key, and in step S602, the root node of the coupled node tree is set as a search start node.
Next, in step S603, the array 309 is searched using the search key set in step S601 to obtain an index key. This search is as shown in FIG. Since the root node is set as the search start node in step S602, the search target is the entire coupled node tree. The contents stored in the search path stack 310 in the search in step S603 are used later in step S606.

  After acquiring the index key in step S603, the process proceeds to step S604, and a difference bit position between the search key set in step S601, that is, the longest match search key, and the index key acquired in step S603 is obtained. Details of this processing will be described later in conjunction with FIG.

Next, in step S605, it is determined whether or not the difference bit position obtained in step S604 is zero.
When the difference bit position is 0, the determination is “yes”, and the longest match search process ends. In this case, the longest match search key and the index key acquired in step S603 do not match the leading 0th bit. Also, due to the coupled node tree structure, all the other index keys included in the coupled node tree also do not match the longest match search key with the first 0th bit. Therefore, since there is no leaf node including an index key that satisfies the partial match condition in the coupled node tree, a search result that “there is no index key that satisfies the longest match condition” is obtained.

  When the difference bit position is not 0, the determination in step S605 is “No”, and the process proceeds to step S606. In this case, there is at least one index key that satisfies the longest matching condition in the coupled node tree. However, since the existence of an index key that satisfies the longest matching condition is only found at the stage of step S605, a specific longest matching node is acquired in step S606.

  In step S606, the search path stack 310 in which the array element number of the array 309 is stored by the search in step S603 is referred to, and the longest matching node is acquired based on the difference bit position obtained in step S604.

  After acquiring the longest matching node, the longest matching node is set as a search start node in the next step S607. Then, in the next step S608, the minimum value search process shown in FIG. 5 is executed from the search start node to acquire the minimum value of the index keys satisfying the longest match condition, and the acquired minimum value is the longest match. The longest match search process is finished as a result of the search.

  Note that steps S607 and S608 can be variously modified according to the embodiment. As in this embodiment, selecting the minimum value from one or more index keys that satisfy the longest matching condition is merely an example of processing. Other modifications will be described later.

Next, the process of step S604 in FIG. 6 will be described with reference to FIG. As will be described later, the process of FIG. 10 is also called from the shortest match search process.
In step S101, the search key is set to the comparison key 1 and the index key is set to the comparison key 2. In the longest match search process, the “search key” here is the longest match search key set in step S601, and the “index key” here is the index key acquired in step S603.

  Next, in step S102, the bit strings of the comparison key 1 and the comparison key 2 are compared in order from the most significant 0th bit. Of the non-matching bits whose values do not match between the comparison key 1 and the comparison key 2, the bit position of the first one found is acquired as the difference bit position, and the processing of FIG. As is clear from the above description, when the process of FIG. 6 from step S604 to FIG. 10 is called, in step S102, the difference bit position between the longest match search key and the index key acquired in step S603 is obtained.

  Next, the process for acquiring the longest matching node performed in step S606 of FIG. 6 will be described with reference to FIG. In order to facilitate understanding of the processing of FIG. 8, the description will be divided into three cases (A1) to (A3).

(A1) When the root node is a leaf node In this case, the index key acquired in step S603 in FIG. 6 is an index key stored in the root node. Therefore, if the difference bit position between the longest match search key and the index key is greater than 0, the index key satisfies the longest match condition, and the root node corresponds to the longest match node.

  Further, as apparent from step S605 of FIG. 6, the process of FIG. 8 is performed only when the difference bit position is greater than 0. In the case of (A1), the root node is always the longest matching node by the process of FIG. Set to Specifically, it is as follows.

In step S801, the stack pointer of the search path stack 310 is returned by one.
In the case of (A1), the array element number of the array 309 stored in the search path stack 310 is only the array element number of the root node. Therefore, after the execution of step S801, the content pointed to by the stack pointer is the array element number of the root node. In this state, the process proceeds to step S802.

  In step S802, it is determined whether or not the stack pointer of the search path stack 310 points to the array element number of the root node. In the case of (A1), since it is as described above, the determination result is “yes”, and the process proceeds to step S808.

In step S808, the array element number pointed to by the stack pointer is extracted from the search path stack 310. That is, in the case of (A1), the array element number of the root node is extracted.
In subsequent step S809, the array element number acquired in step S808, that is, the array element number of the root node is set as the array element number of the longest matching node, and the process of FIG. 8 ends.

(A2) When the root node is a branch node and the discrimination bit position of the root node is 0. In this case, the 0th bit is 0 and the 0th bit is 1 index key. Contains the tree. Therefore, there is always an index key that matches at least the 0th bit. This means that there is always an index key that satisfies the longest matching condition, and that the difference bit position acquired in step S604 in FIG. That is, in the case of (A2), the determination in step S605 is always “No”, and the process of FIG. 8 is always executed.

  In step S801, the stack pointer of the search path stack 310 is returned by one. As a result, the content pointed to by the stack pointer is the array number of the leaf node that stores the index key acquired in step S603. In the case of (A2), this leaf node is not a root node. After execution of step S801, the loop of steps S802 to S806 is repeatedly executed. This loop is an operation that goes back through the search path stack 310.

  In step S802, it is determined whether or not the stack pointer of the search path stack 310 points to the array element number of the root node. In the case of (A2), the determination at the time when step S802 is executed for the first time is “No”, and the process proceeds to step S803.

  In step S803, the stack pointer of the search path stack 310 is returned by 1, and the array element number pointed to by the stack pointer is extracted. In the subsequent step S804, the array element indicated by the array element number acquired in step S803 is read from the array 309 as a node. In the next step S805, the discrimination bit position is extracted from the node read in step S804.

  Note that steps S803 to S806 are executed only when the determination in step S802 is “No”. Therefore, it is guaranteed that no underflow will occur when the stack pointer is returned by one in step S803. 4 and step S802, steps S803 to S806 are executed when one or more array element numbers of nodes other than the root node are stored in the search path stack 310. Therefore, after execution of step S803, the stack pointer points to the array element number of the branch node that is the root node or other branch nodes.

  In step S806 following step S805, it is determined whether or not the extracted discrimination bit position is higher than the difference bit position obtained in step S102 of FIG. If the discrimination bit position is higher than the difference bit position, the determination is “yes” and the process proceeds to step S807. If it is lower, the determination is “no” and the process returns to step S802.

  In the case of (A2), after the loop of steps S802 to S806 has been repeatedly executed one or more times, the determination in step S806 is “Yes”, and the process proceeds in the order of steps S807, S808, and S809.

  In step S807, the stack pointer of the search path stack 310 is advanced by one. Since step S807 is executed after step S803 has been executed one or more times, no overflow occurs due to the operation of step S807.

  In subsequent step S808, the array element number pointed to by the stack pointer is extracted from the search path stack 310, and in the next step S809, the array element number acquired in step S808 is set as the array element number of the longest matching node, and the process of FIG. .

The node set as the longest matching node in the case of (A2) by the above processing is the following 2
One of the two.
When the discrimination bit position of the branch node linked to the leaf node storing the index key acquired in step S603 is higher than the difference bit position, the leaf node is set as the longest matching node.

  The array number of the branch node whose discrimination bit position is m and the array number of the branch node linked from the branch node and whose discrimination bit position is n are sequentially stored in the search path stack 310, and are distinguished from the discrimination bit position m. When the relationship between the bit position n and the difference bit position d is m <d <n, the branch node whose discrimination bit position is n is set as the longest matching node.

(A3) When the root node is a branch node and the discrimination bit position of the root node is greater than 0 In this case, the determination of step S605 in FIG. Different.

  In step S801, the stack pointer of the search path stack is returned by 1, the determination in step S802 is always “NO” at the first execution of the loop in steps S802 to S806, and the operations in subsequent steps S803 to S806 are as follows. , (A2).

  If the determination is “No” in step S806 and the process returns to step S802, the determination in step S802 is performed again. The case of (A3) differs from the case of (A2) in that the determination may be “yes” in the second and subsequent executions of step S802.

  As described above, the determination is always “No” at the first execution of Step S802. When step S802 is executed for the second time or later, step S806 is executed immediately before, and “NO” is determined in step S806. That is, as a result of repeating the loop one or more times, the search path stack 310 is traced until the stack pointer points to the root node array number, and the discrimination bit position of the root node is lower than the difference bit position. Only in this case, “Yes” is determined in step S802.

  If “Yes” is determined in step S802, the process proceeds to step S808, and the array element number of the root node is set to the array element number of the longest matching node as in the case of (A1), and the processing in FIG. .

  In the case of (A3), since the discrimination bit position of the root node is larger than 0, the relationship between the discrimination bit position m of the root node and the difference bit position d is as follows. All index keys included in the coupled node tree share the 0th to (m−1) th bits. In the case of (A3), if “Yes” is determined in step S802, 0 <d <m. Therefore, in this case, all the index keys included in the coupled node tree have the 0th to (d-1) th bits matching the longest match search key. Therefore, in this case, as described above, the array element number of the root node is set to the array element number of the longest matching node.

  Similarly to the case of (A2), also in the case of (A3), after the loop of steps S802 to S806 is repeated one or more times, the determination in step S806 becomes “Yes”, and steps S807 and S808 are performed. , S809 may proceed in order. The contents of the process in that case are the same as in the case of (A2).

  Next, a specific example of the longest match search will be described with reference to FIG. The coupled node tree of FIG. 11 includes eight index keys “000111”, “010010”, “010011”, “011010”, “100010”, “1000011”, “101100”, and “101111”. Since the coupled node trees of FIG. 11 and FIG. 2 have the same structure, the same reference numerals are assigned. However, the value of the discrimination bit position 231f of the node 211f, the value of the index key 250h of the node 210h, and the value of the index key 251h of the node 211h are different from those in FIG.

Hereinafter, a case where “101010” is designated as the longest match search key will be described.
In step S601 in FIG. 6, “101010” is set as the search key, and in step S602, the root node is set as the search start node. When the process of FIG. 4 is called from step S603, array numbers 220, (220a + 1), (221b + 1), and (221f + 1) are stored in the search path stack 310 in order. The index key obtained in step S603 is “101111” stored in the index key 251h of the node 211h that is the array element of the array element number (221f + 1). In FIG. 11, this is indicated by “initial search” next to the node 211h.

  In step S604, the difference bit position between the index key 251h having a value of “101111” and the search key having a value of “101010” is obtained. Since the value 3 is greater than 0, the determination in step S605 is “no”. Therefore, step S606, that is, the process of FIG. 8 is executed. When the search path stack 310 is traced back by repeating steps S802 to S806 and the array element number (220a + 1) is obtained, the discrimination bit position 231b of the node 211b stored in the array element of the array element number (220a + 1) is 2, and the discrimination bit is Since the relationship between the position and the difference bit position is 2 <3, “Yes” is determined in step S806. Therefore, the stack pointer is advanced by 1 in step S807, the array element number (221b + 1) is extracted in step S808, and the array element number (221b + 1) is set as the array element number of the longest matching node. That is, the node 211f stored in the array element with the array element number (221b + 1) is set as the longest matching node.

  Here, the processing returns to FIG. 6. In step S607, the node 211f is set as the search start node, and the processing of step S608, that is, the minimum value search of FIG. 5 is performed. As shown in FIG. 11, there are two leaf nodes, the node 210h and the node 211h, which are descendants of the node 211f which is the branch node set as the longest matching node. The index key values of both nodes are “101100” and “101111”. In any case, the longest match search key “101010” matches 0th to 2nd bits and does not match 3rd bit. Further, the other six index keys included in the coupled node tree all have a difference bit position smaller than 3 with respect to the longest match search key “101010”. By the process of step S608, “101100” which is the minimum value among “101100” and “101111” is selected, and the process of FIG. 6 ends.

Next, a specific method of the shortest match search of the coupled node tree will be described with reference to FIGS.
FIG. 7 is a flowchart of the shortest match search process according to an embodiment of the present invention. FIG. 7 is a diagram in which “longest match” in FIG. 6 is changed to “shortest match”.

First, in step S701, the shortest match search key is used as a search key, and in step S702, the root node is set as a search start node.
Next, in step S703, the array is searched using the search key set in step S701, and the index key is acquired. This search is as shown in FIG. Since the root node is set as the search start node in step S702, the search target is the entire coupled node tree. The contents stored in the search path stack 310 in the search in step S703 are used later in step S706. After obtaining the index key, the process proceeds to step S704.

  In step S704, the difference bit position between the search key set in step S701, that is, the shortest match search key, and the index key acquired in step S703 is obtained.

  Details of this processing are as already described in conjunction with FIG. However, when the process of FIG. 10 is called from step S704, the longest point is that the comparison key 1 set in step S101 is the shortest match search key and the comparison key 2 is the index key acquired in step S703. Different from the case of matching search.

After execution of step S704, in step S705, it is determined whether or not the difference bit position obtained in step S704 is zero.
When the difference bit position is 0, the determination is “yes” and the shortest match search process is terminated. In this case, the shortest matching search key and the index key acquired in step S703 do not match the leading 0th bit. Also, due to the coupled node tree structure, all the other index keys included in the coupled node tree also have a mismatch between the shortest match search key and the first 0th bit. Therefore, a search result “an index key that satisfies the shortest matching condition does not exist” is obtained.

  When the difference bit position is not 0, the determination in step S705 is “No”, and the process proceeds to step S706. In this case, there is at least one index key satisfying the shortest matching condition in the coupled node tree. However, since the existence of an index key that satisfies the shortest matching condition is only found at the stage of step S705, a specific shortest matching node is acquired in step S706. When the index keys of all leaf nodes included in a certain subtree satisfy the shortest matching condition, the root node of the subtree is defined as the shortest matching node.

  In step S706, the search path stack 310 in which the array element number of the array 309 is stored by the search in step S703 is referred to, and the shortest matching node is acquired based on the difference bit position obtained in step S704.

  After acquiring the shortest matching node, the shortest matching node is set as a search start node in the next step S707. Then, in the next step S708, the minimum value search process shown in FIG. 5 is executed from the search start node, the minimum value of the index keys satisfying the shortest match condition is acquired, and the acquired minimum value is the shortest match The result of the search is output and the shortest match search process is terminated.

As in FIG. 6, steps S707 and S708 can be variously modified depending on the embodiment.
Next, the process for acquiring the shortest matching node performed in step S706 of FIG. 7 will be described with reference to FIG. The process of FIG. 9 is a process according to the definition of the “shortest match condition” in (b) above, but in order to make the process of FIG. 9 easier to understand, the description will be made for the four cases (B1) to (B4). Do it separately. (B1) and (B2) are the cases where the array number of at least three nodes is stored on the search path stack as a result of the search using the shortest match key, and (B3) and (B4) are the other cases. is there.

(B1) The root node is a branch node, and there is at least one branch node other than the root node on the path from the root node to the leaf node storing the index key acquired in step S703. When the discrimination bit position of m is m, the shortest matching search key and the index key having the same range from the 0th to mth bits exist. In this case, there are at least three nodes on the path. The search path stack 310 stores array element numbers in the order of a root node, a branch node that is a child node of the root node, and a child node of the branch node. From the definition of (b) above, in this case, the node that is linked from the branch node that is a child node of the root node and that is paired with the node whose array element number is stored in the search path stack 310 corresponds to the shortest matching node. The process of FIG. 9 in the case of (B1) is a process of setting this node as the shortest matching node.

First, in step S901, the stack pointer of the search path stack 310 is set in the save area.
Subsequent steps S902 to S903 form a loop and are repeatedly executed one or more times. This loop represents going up the search path stack 310 until the stack pointer points to the array element number of the root node. First, in step S902, the stack pointer of the search path stack 310 is returned by one. In subsequent step S903, it is determined whether or not the stack pointer of the search path stack 310 points to the array element number of the root node. If the stack pointer points to the array element number of the root node, the determination is “yes” and the process proceeds to step S904. Otherwise, the determination is “no” and the process returns to step S902.

  In step S904, the stack pointer is compared with the value in the save area. Here, step S904 is executed only when the stack pointer points to the array element number of the root node. That is, step S904 is a process for checking how far the stack pointer immediately before the start of the process of FIG. 9 is away from the stack pointer indicating the array element number of the root node. The process is branched according to the process.

  In the case of (B1), since the search path stack 310 stores the array numbers of at least three nodes as described above, the comparison result in step S904 is always “difference> 2.” Therefore, the process always proceeds to step S905.

  In step S905, the array element number indicated by the stack pointer, that is, the array element number of the root node is extracted from the search path stack 310. In subsequent step S906, the array element indicated by the array element number extracted in step S905 is read from array 309 as a node. In the next step S907, the discrimination bit position is extracted from the node read out in step S906, that is, the root node.

  In subsequent step S908, it is determined whether or not the discrimination bit position extracted in step S907 is higher than the difference bit position obtained in step S102 of FIG. If the discrimination bit position is higher than the difference bit position, the determination is “yes” and the process proceeds to step S909. If the discrimination bit position is lower, the determination is “no” and the process proceeds to step S914.

In the case of (B1), the determination in step S908 is always “Yes”. The reason is as follows.
Since the process of FIG. 9 is executed only when the difference bit position is greater than 0, the determination in step S908 is always “Yes” when the discrimination bit position of the root node extracted in step S907 is 0.

  When the discrimination bit position of the root node extracted in step S907 is greater than 0, assuming that the discrimination bit position of the root node is m, all index keys included in the coupled node tree are 0 to (m−1). The bit range is the same. In the case of (B1), there is an index key that matches the shortest matching search key up to the m-th bit. Therefore, since all index keys included in the coupled node tree have a range of 0th to (m−1) th bits that matches the shortest match search key, the relationship between the discrimination bit position m and the difference bit position d is m ≦ d. Therefore, the determination in step S908 is always “Yes”.

If “YES” is determined in step S908, the stack pointer of the search path stack 310 is advanced by two in step S909.
In subsequent step S910, the array element number pointed to by the stack pointer is extracted from the search path stack 310.

In the next step S911, the sequence number that is paired with the sequence number obtained in step S910 is obtained.
After execution of step S911, the process proceeds to step S914, and the array element number obtained in step S911 is set as the array element number of the shortest matching node. Then, the process of FIG. 9 ends.

(B2) The root node is a branch node, and there is at least one branch node other than the root node on the path from the root node to the leaf node storing the index key acquired in step S703. When the discrimination bit position of m is m, there is no index key that matches the shortest match search key and the range from the 0th to mth bits. In this case, the difference from (B1) is that the shortest match search key and 0 to m bits It is only a point that there is no index key that matches the range up to the eye. Therefore, the processing up to step S907 is exactly the same as in the case of (B1).

  In step S908 following step S907, it is determined as “No” in the case of (B2), and the process proceeds to step S914. In this case, the array element number is the array element number extracted in step S905, that is, the array element number of the root node. Therefore, in step S914, the array element number of the root node is set to the array element number of the shortest matching node, and the process ends.

(B3) When the root node is a branch node and the leaf node storing the index key acquired in step S703 is linked from the root node. In this case, there are only two nodes on the path. That is, the search path stack 310 is in a state in which the array number of the root node and the array number of the leaf node that stores the index key are stored.

  Also in the case of (B3), steps S901 to S903 are the same as in the case of (B1). However, the comparison result in step S904 subsequent to step S903 is different from that in the case of (B1). In the case of (B3), the value set in the save area in step S901 is compared with the stack pointer, and a result of “difference = 2” is obtained. Therefore, the process always proceeds to step S912.

  In step S912, the stack pointer of the search path stack 310 is advanced by one. In the next step S913, the array element number pointed to by the stack pointer is extracted from the search path stack 310. That is, the array number of the leaf node is extracted. Then, the process proceeds to step S914, the array element number of the leaf node extracted in step S913 is set as the array element number of the shortest matching node, and the process ends.

(B4) When the root node is a leaf node In this case, the index key acquired in step S703 in FIG. 7 is the index key stored in the root node. Therefore, if the difference bit position between the shortest match search key and the index key is greater than 0, the index key satisfies the shortest match condition, and the root node corresponds to the shortest match node. Further, as apparent from step S705 of FIG. 7, the process of FIG. 9 is performed only when the difference bit position is greater than 0. In the case of (B4), the root node is always the shortest matching node by the process of FIG. Set to Specifically, it is as follows.

Step S901 is the same as in the case of (B1).
In subsequent step S902, the value of the stack pointer is decreased by one. In the case of (B4), the array element number of the array 309 stored in the search path stack 310 is only the array element number of the root node. Therefore, after execution of step S902, the array element number pointed to by the stack pointer is the array element number of the root node. In this state, the process proceeds to step S903.

  In step S903, it is determined whether or not the stack pointer of the search path stack 310 points to the array element number of the root node. In the case of (B4), since it is as described above, the determination result is “yes”, and the process proceeds to step S904.

  In step S904, the stack pointer is compared with the value in the save area. In the case of (B4), the result “difference = 1” is obtained, and the process proceeds to step S913 according to this result.

  In step S913, the array element number indicated by the stack pointer, that is, the array element number of the root node is extracted from the search path stack 310. In subsequent step S914, the array element number of the root node is set to the array element number of the shortest matching node, and the process of FIG. 9 ends.

Next, a specific example of the shortest match search will be described with reference to FIG. The coupled node tree of FIG. 12 is exactly the same as that of FIG.
Hereinafter, a case where “101010” is designated as the shortest match search key will be described.

  The processing in steps S701 to S705 in FIG. 7 is exactly the same as the example in FIG. In step S705, “NO” is determined, and step S706, that is, the process of FIG. 9 is executed. First, in step S901, the value of the stack pointer is set in the save area. Next, the search path stack 310 is traced back by repeating steps S902 to S903, and when the array element number 220 is obtained, the determination in step S903 becomes “Yes” and the process proceeds to step S904. Here, the stack pointer and the value of the save area are compared, and as a result, the process proceeds to step S905, and the discrimination bit position 230a of the root node 210a is extracted by steps S905 to S907. Since the value of the discrimination bit position 230a is 0, the determination in step S908 is “Yes”, and the stack pointer is advanced by 2 in step S909. As a result, in step S910, the array element number (221b + 1) is extracted, and in step S911, the array element number 221b paired with it is acquired. Therefore, in step S914, the array element number 221b is set as the array element number of the shortest matching node.

Here, the processing returns to FIG. 7. In step S707, the node 210f which is the shortest matching node is set as the search start node, and the processing of step S708, that is, the minimum value search of FIG. 5 is performed. As shown in FIG. 12, the leaf nodes that are descendants of the node 210f that is the branch node set as the shortest matching node are the node 210g and the node 211g. The index key values of both nodes are “1000011” and “100010”. In any case, the 0th to 1st bits match with the shortest match search key “101010”, and the second bit does not match.

  Compared with the discrimination bit position in the branch node on the route from the root node, the discrimination bit position 230a of the root node 210a is 0, and the discrimination bit position 231b of the next node 211b is 2. Therefore, the two index keys match the shortest match search key in the range of the 0th to 0th bits, and there are mismatched bits in the range of the 1st to 2nd bits.

  On the other hand, other index keys included in the coupled node tree are index keys 250c, 251d, 250e, and 251e that do not satisfy the partial matching condition, and index keys 250h that match the 0th to 2nd bits and the 3rd bit do not match. And 251h. Therefore, it can be seen that the shortest matching search preferentially searches for the shortest matching portion of the index keys that partially match the shortest matching search key.

In the above embodiment, “100010”, which is the minimum value of “100011” and “100010”, is selected in step S708.
The embodiment of the present invention is not limited to the above-described embodiment, and various modifications can be made.

  In the above embodiment, the physical bit position of the leftmost corresponds to the logical bit position of the most significant, but in another embodiment, another correspondence relationship may be used, for example, the rightmost The bit may be the most significant bit. The determination in step S806 in FIG. 8 or step S908 in FIG. 9 is a determination according to a logical bit position.

  In the above longest match search, the minimum value of the index keys satisfying the longest match condition is acquired as a result. However, it is possible to modify the above longest match search process so as to obtain a search result suitable for various embodiments. For example, the maximum value of the index keys that satisfy the longest matching condition may be acquired as a result of the longest matching search process.

Similarly, what is acquired as the search result for the shortest match search also varies depending on the embodiment.
In the loop of steps S902 to S903 in FIG. 9, the search path stack 310 is traced back one by one. However, for example, this loop may be replaced with a step of substituting the stack pointer indicating the array element number of the root node for the stack pointer.

  Further, details of the definition of the shortest match search can be variously modified according to the embodiment. When the difference bit position obtained in step S704 of FIG. 7 is a value between the discrimination bit position of the root node and the branch node immediately below the root node, the process of FIG. 9 is modified so that the branch node immediately below the root node. May be set as the shortest matching node.

  Further, when the discrimination bit position of the root node is larger than 0 and smaller than the difference bit position obtained in step S704, another modification is possible. In this case, the highest difference bit position with the shortest match search key is the root of the node pair that is linked from the root node and whose array number is not stored in the search path stack 310 in the search in step S703. An index key stored in a leaf node included in a subtree as a node. Therefore, when the determination in step S908 is “Yes”, if the value of the discrimination bit position of the root node is greater than 0, the process of FIG. 9 may be modified to advance the stack pointer by one in step S909.

Further, when the difference bit position obtained in step S704 is smaller than the value of the discrimination bit position of the root node, the processing of FIG. 9 may be modified to set the root node to the shortest matching node.

  If the value of the discrimination bit position of the root node is larger than 0 and smaller than the value of the difference bit position obtained in step S704, the array element number paired with the array element number extracted in step S913 is set to the array element number of the shortest matching node. May be set as

  Of course, the longest match / shortest match search method described above can be executed by a computer by a program.

It is a figure explaining the structural example of the coupled node tree stored in the arrangement | sequence. It is a figure which shows notionally the tree structure of a coupled node tree. It is a figure explaining the hardware structural example for implementing this invention. It is a flowchart which shows the basic operation | movement of a bit string search. It is a flowchart which shows the process which calculates | requires the minimum value of the index key stored in the coupled node tree. It is a flowchart which shows the longest match search process. It is a flowchart which shows the shortest match search process. It is a flowchart which shows the process which acquires the longest matching node. It is a flowchart which shows the process which acquires the shortest matching node. It is a flowchart which shows the process which acquires a difference bit position. It is a figure explaining an example of the longest match search by a coupled node tree. It is a figure explaining an example of the shortest match search by a coupled node tree. It is a figure which shows an example of the Patricia tree used by the conventional search.

Explanation of symbols

10, 20, 30 SEQ ID NO: 100 Array 101 Node 102, 114, 117, 124, 126, 260a-260h, 261b-261h
Node type 103, 115, 230a to 230f, 231b to 231f Discrimination bit position 104, 116, 220, 220a to 220f, 221b to 221f Representative node number 111, 121, 201a to 201h Node pair 112, 122, 210a to 210h Node [ 0], representative nodes 113, 123, 211b to 211h node [1], nodes 118, 125, 126, 250c to 250h, 251d to 251h paired with representative nodes Index key 301 data processing device 302 central processing device 303 cache memory 304 Bus 305 Main storage device 306 External storage device 307 Communication device 308 Data storage device 309 Array 310 Search path stack 1730a-1730h Check bit position 1740a-1740f Left link 1741a to 1741f Right link 1750a to 1750h Index key

Claims (9)

A tree used for a bit string search consisting of a root node and a branch node and a leaf node or a node pair between branch nodes or leaf nodes arranged in an adjacent storage area,
The root node is a node representing a starting point of a tree, and when the tree has one node, the leaf node is used. When the tree has two or more nodes, the root node is the branch node.
The branch node includes position information indicating a discrimination bit position of a search key for performing a bit string search and a representative node that is one node of a link destination node pair, and the leaf node is an index key including a bit string to be searched Including
An arbitrary node of the tree is set as a search start node, and in the branch node, in the storage node adjacent to the representative node of the link destination node pair or in accordance with the bit value of the search key at the discrimination bit position included in the branch node The search for an arbitrary subtree of the tree with the index key stored in the leaf node as the root node, using the index key stored in the leaf node by sequentially linking to the arranged nodes until reaching the leaf node A longest match search method using a coupled node tree configured to be a search result key that is a search result by key,
The search result key is obtained by performing the search while storing a route from the root node using the root node of the coupled node tree as the search start node and the designated longest match search key as the search key. A search step to
A difference bit position acquisition step of comparing the bit string of the longest match search key and the search result key and acquiring a difference bit position that is the highest position among the positions of mismatch bits where the bit values do not match,
A longest match node setting step of setting a longest match node with reference to the stored path when the difference bit position is a position other than the highest bit of a bit string,
When the root node is the leaf node or when the root node is the branch node and the discrimination bit position of the root node is a position lower than the difference bit position, the root node is set as the longest matching node. Set,
In other cases, in the search step next to the branch node having the lowest discrimination bit position among the branch nodes that are nodes on the path and the discrimination bit position is higher than the difference bit position. A longest match node obtaining step of obtaining the stored branch node or the leaf node as the longest match node;
A longest match search method comprising:   The method further comprises an index key acquisition step of selecting the leaf node included in a subtree of the coupled node tree having the longest matching node as a root node, and acquiring an index key included in the selected leaf node. The longest match search method according to claim 1.   The coupled node tree is stored in an array, and the position information is an array element number of an array element of the array in which the representative node corresponding to the position information is stored. The longest match search method.   4. The longest path according to claim 3, wherein in the search step, the path is stored by sequentially holding the array element numbers of the array elements in which nodes on the path are stored in a stack. Match search method. A tree used for a bit string search consisting of a root node and a branch node and a leaf node or a node pair between branch nodes or leaf nodes arranged in an adjacent storage area,
The root node is a node representing a starting point of a tree, and when the tree has one node, the leaf node is used. When the tree has two or more nodes, the root node is the branch node.
The branch node includes position information indicating a discrimination bit position of a search key for performing a bit string search and a representative node that is one node of a link destination node pair, and the leaf node is an index key including a bit string to be searched Including
An arbitrary node of the tree is set as a search start node, and in the branch node, in the storage node adjacent to the representative node of the link destination node pair or in accordance with the bit value of the search key at the discrimination bit position included in the branch node The search for an arbitrary subtree of the tree with the index key stored in the leaf node as the root node, using the index key stored in the leaf node by sequentially linking to the arranged nodes until reaching the leaf node A shortest match search method using a coupled node tree configured to be a search result key that is a result of a search by key,
Using the root node of the coupled node tree as the search start node and the designated shortest match search key as the search key, performing the search while storing a route from the root node to obtain the search result key A search step to
A difference bit position acquisition step of comparing the bit string of the shortest match search key and the search result key to acquire a difference bit position that is the highest position among the positions of mismatch bits where the bit values do not match,
A shortest match node setting step of setting a shortest match node with reference to the stored path when the difference bit position is a position other than the highest bit of a bit string,
The path includes the root node and a first node that is one of the branch nodes of the node pair to which the root node is linked, and the discrimination bit position of the root node is greater than the difference bit position. In the case of an upper position, the shortest matching node acquisition that acquires, as the shortest matching node, the second node that is the node that is not stored in the route among the node pairs linked to the first node Steps,
A shortest match search method comprising:   The method further comprises an index key acquisition step of selecting the leaf node included in a subtree of the coupled node tree having the shortest matching node as a root node, and acquiring an index key included in the selected leaf node. The shortest match search method according to claim 5.   6. The coupled node tree is stored in an array, and the position information is an array element number of an array element of the array in which the representative node corresponding to the position information is stored. The shortest match search method.   8. The shortest path according to claim 7, wherein in the search step, the path is stored by sequentially holding the array element numbers of the array elements in which nodes on the path are stored in a stack. Match search method.   The program for making a computer perform the longest match search method of any one of Claims 1-4, or the shortest match search method of any one of Claims 5-8.

Images