JP2009251840A - Bit sequence search device, search method, and program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a data structure of a coupled node tree which has released the limit that nodes constituting a pair should be arranged in adjacent storage regions, and various search methods using the data structure. <P>SOLUTION: A branch node includes position information on one and the other of the nodes constituting a pair at a link destination. Index key search is realized by repeating, until a leaf node is reached, the process of selecting the position information on one of the first and the second node in accordance with the bit value of a search key at a discrimination bit contained in the branch node, and the process of making a linkage to one of the nodes constituting a pair according to the selected position information. <P>COPYRIGHT: (C)2010,JPO&INPIT

Description

  The present invention relates to a search process for searching for a desired bit string from a set of bit strings using a tree-like data structure for storing the bit strings. In particular, the present applicant has disclosed Japanese Patent Application Laid-Open No. 2008-015862 and Japanese Patent Application No. 2006. The present invention relates to a search device, a search method, and a program using a coupled node tree proposed in 293619.

  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. 1 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. 1, the node 1750a holding the index key “100010” is the root node, and the 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 1730c is 3. The index key held by the node 1750d is “011010”, and the check bit position 1730d 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. 1, 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, the storage capacity of the same capacity as the node needs to be allocated to the left pointer 1740c, the right pointer 1741h, etc., which is the lowermost part 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 problems in the above-described conventional search method, the present applicant has disclosed a root node, a branch node and a leaf node arranged in adjacent storage areas in Japanese Patent Application No. 2006-187827 below. Or a tree used for bit string search consisting of a pair of nodes between branch nodes or leaf nodes, and the root node is a node representing the starting point of the tree, and when there is only one node in the tree, the node of the leaf node or tree Is a branch node, and the branch node includes position information indicating a discrimination bit position of a search key for performing a bit string search and a position of a representative node that is one node of a link destination node pair. The leaf node includes a coupled node including an index key composed of a bit string to be searched. A bit string search using Dotsuri disclosed. In Patent Document 2, a basic method using a coupled node tree, such as a method of generating a coupled node tree from a given set of index keys and a method of retrieving a single index key from the coupled node tree. Search techniques are shown. It is also explained that the configuration of a coupled node tree is uniquely defined by a set of index keys.

  In the search for bit strings, there are various search requests such as obtaining a minimum value and a maximum value, and obtaining a value within a certain range. In view of this, the applicant of the present application disclosed in Japanese Patent Application No. 2006-293619 a generalized search for an index key included in an arbitrary subtree of a coupled node tree or a method for obtaining a maximum value / minimum value of an index key and a coupled node. We proposed a method to extract index keys stored in the tree in ascending or descending order. A search using an arbitrary node of a coupled node tree, which is a generalized search technique, as a search start node is performed by using an arbitrary subtree of the coupled node tree having the search start node as a root node as a search target. The search is executed by The search is performed by linking to the representative node of the link destination node pair or a node arranged in a storage area adjacent thereto according to the bit value of the search key of the discrimination bit position included in the branch node in the branch node. Are sequentially repeated until the leaf node is reached, and an index key included in the leaf node is obtained as a search result key.

The method for obtaining the maximum value / minimum value of the index key is to link only the representative node or a node paired with the representative node (hereinafter, also referred to as a non-representative node) to the leaf node. The method of extracting the index keys stored in the node tree in ascending order or descending order uses the fact that the index keys are arranged with order in the coupled node tree, as will be described later. Are repeated based on the order, and the minimum value search or maximum value search is repeated. In each of the above applications, the coupled node tree is arranged in an array, and the array number of the search path node on the tree from the search start node in each of the proposed search processes is sequentially stacked on the search path stack, and the search is performed. A process using array numbers stacked in the path stack is also disclosed.
JP 2001-357070 A JP 2008-015862 A

  Regarding the arrangement of the coupled node tree in the storage area proposed in each of the above-mentioned applications, as described above, it is specified that the nodes forming a pair are arranged in adjacent storage areas. Then, in the branch node including the position information indicating the position of the representative node that is one node of the link destination node pair, the search is performed according to the bit value of the search key of the discrimination bit position included in the branch node. This is realized by sequentially linking to a representative node of a link destination node pair or a node arranged in a storage area adjacent to the link destination node by position information until the leaf node is reached.

  Therefore, in the coupled node tree proposed in each of the above applications, it is essential that the paired nodes are arranged in adjacent storage areas. This condition is a kind of usage of the storage area in which the nodes are arranged. In some cases, this limitation is not preferable.

  Therefore, the problem to be solved by the present invention is to provide a data structure of a coupled node tree that removes the restriction that “paired nodes are arranged in adjacent storage areas” and various search methods using the data structure. It is to be.

  The branch node of the coupled node tree according to the present invention replaces the position information indicating the position of the representative node that is one node of the linked node pair with the position information of one node and the position of the other node of the node pair. Contains information. In the search of the index key, the position information of one node or the other node is selected according to the bit value of the search key of the discrimination bit position included in the branch node, and either of the node pair is selected according to the selected position information. Linking to the node is realized by sequentially repeating the process until reaching the leaf node.

  According to the present invention, since the branch node includes the position information of one node of the node pair as the link destination and the position information of the other node, “the paired nodes are arranged in adjacent storage areas”. The restriction can be removed, and the addresses where the paired nodes are arranged can be separated.

As described above, in the following description, the coupled node tree according to the present invention may be referred to as an address separation type coupled node tree. It may also be simply a tree.
First, an example in which a coupled node tree according to the present invention is stored in an array will be described. 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. 2A is a diagram illustrating a configuration example of an address separation type coupled node tree stored in an array according to an embodiment of the present invention.
Referring to FIG. 2A, the node 101 is arranged in the array element of array number 10 in the array 100. The node 101 includes a node type 102, a discrimination bit position 103, a node number [0] 104a, and a node number [1] 104b. 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 node number [0] 104a and the node number [1] 104b store the array element numbers 12 and 13 of the link destination nodes, respectively. In the following, for simplification of description, the array number stored in the node number [0] or the node number [1] may be referred to as the node number [0] or the node number [1], respectively. In addition, the array element number stored in the node number [0] or the node number [1] may be represented by a code attached to the node.

As shown in the figure, the array elements in which the node 112 and the node 113, which are the lower paired nodes of the node 101, are not adjacent to each other, and their addresses (array numbers) are not continuous but separated. Is. Of course, it is also possible to store consecutive array numbers 12 and 13 in the node number [0] 104a and the node number [1] 104b. In this case, the array elements in which the nodes 112 and 113 are arranged are adjacent to each other. Will be.
The node 112 is stored in the array element of the array element number 12. A node 113 is stored in the array element with array number 13.
0 is stored in the node type 114 of the node 112, 3 is stored in the discrimination bit position 115, and the array numbers 22 and 23 of the link destination nodes are stored in the node number [0] 116a and the node number [1] 116b, respectively. Yes. Further, 1 is stored in the node type 117 of the node 113, indicating that the node 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 node stored in an array element with a certain array number may be referred to as a node with that array number, and an array number of an array element in which a node is stored may be referred to as a node array number.
The contents of the nodes 122 and 123 stored in the array elements having array numbers 22 and 23 are omitted.

FIG. 2B is a diagram conceptually illustrating a tree structure of an address-separated coupled node tree according to an embodiment of the present invention. The 6-bit index key shown is the same as that of the Patricia tree illustrated in FIG. Moreover, it is the same as that illustrated in FIG.
A reference numeral 210a indicates a root node. In the illustrated example, the root node 210a is assumed to be stored in the array element having the array element number 220.
In the tree structure, a node 210b and a node 211b that make a pair are arranged below the root node 210a, and a node 210c and a node 211c that make a pair, and a node 210f and a node 211f that make a pair are arranged below the root node 210a. A pair of nodes 210h and 211h and a pair of nodes 210g and 211g are arranged below the pair of nodes 210f and 211f. A pair of node 210d and node 211d are arranged below the paired node 210c and node 211c, and a pair of node 210e and node 211e are arranged below that.

  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 node number [0] 220a and the node number [1] 240a store the array element numbers of the array elements stored in the node 210b and the node 211b that make a pair, respectively. In the following description, the symbols indicating the node number [0] and the node number [1] are also used to represent the array numbers stored in them.

The node types 260b and 261b of the nodes 210b and 211b are both 0, indicating that they are branch nodes. 1 is stored in the discrimination bit position 230b of the node 210b, and the node number [0] and the node number [1] are 220b and 240b, respectively, which are the array elements stored in the paired nodes 210c and 211c, respectively. Is the SEQ ID NO.
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, and the discrimination bit position 231c is 2. The node number [0] and the node number [1] are 221c and 241c, respectively, which are the array element numbers of the array elements stored in the nodes 210d and 211d that make a pair.

The node type 260d of the node 210d is 1, and “011010” is stored in the index key 250d. The node type 261d of the node 211d paired with the node 210d is 0, the discrimination bit position 231d is 5, and the node number [0] and the node number [1] are 221d and 241d, respectively. They are the array element numbers of the array elements in which the node 210e and the node 211e that make a pair are stored.
The node types 260e and 261e of the nodes 210e and 211e which are paired nodes are both 1, indicating that both are leaf nodes. “010010” and “010011” are used as index keys for the index keys 250e and 251e, respectively. Is stored.
2 is stored in the discrimination bit position 231b of the node 211b paired with the node 210b, and the node number [0] and the node number [1] are 221b and 241b, respectively. They are the array element numbers of the array elements in which the node 210f and the node 211f that make a pair are stored.

The node types 260f and 261f of the nodes 210f and 211f are both 0, and both are branch nodes. 5 and 3 are stored in the discrimination bit positions 230f and 231f, respectively. The node number [0] and the node number [1] of the node 210f are 220f and 240f, respectively, which are the array element numbers of the array elements stored in the node 210g and the node 211g that make a pair. The node number [0] and the node number [1] of the node 211f are 221f and 241f, respectively, which are the array element numbers of the array elements stored in the node 210h and the node 211h, respectively.
The node types 260g and 261g of the nodes 210g and 211g are both 1, indicating that both are leaf nodes, and “100010” and “1000011” are stored in the index keys 250g and 251g, respectively.
Similarly, the node types 260h and 261h of the node 210h and the node 211h that is paired with the node 210h are both 1, indicating that both are leaf nodes, and “101011” and “101100” are stored in the index keys 250h and 251h, respectively. Has been.

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 240a stored in the node number [1] 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, so the array number stored in the node number [0] Link to the node 210f stored in the array element 221b.

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, so the array number stored in the node number [0] Link to the node 210g stored in the array element 220f.
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 an address separation type coupled node tree is performed.

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.

FIG. 4 is a flowchart for explaining the basic operation of the bit string search according to the embodiment of the present invention.
First, in step S401, the array element number of the search start node is set in a search start node setting area (not shown). The array element corresponding to the set array number stores an arbitrary node constituting the separated coupled node tree.
The array number of the search start node is set by designating or acquiring the array number of the search start node and setting the array number or the node of the array number in a search start node setting area (not shown). Note that the search start node setting area described above is one of the “temporary storage devices corresponding to each process in order to use various values obtained during the process in a later process”. In the following explanation, instead of the expression “set in the search start node setting area (not shown)”, it may be described as “set as search start node” or simply “set as search start node”. is there. The same applies to other than the search start node.

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 S409, the node number [i] corresponding to the bit value “i” extracted in step S407 is extracted from the node, and the process returns to step S402 as a new array number. In order to extract the node number [i] corresponding to the bit value “i”, for example, the address of the node number [i] is calculated by adding the start address of the node number [0] + (i * node number [0] length). It will be apparent to those skilled in the art that it is feasible by determination.
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.

Next, node insertion processing in the address separation type coupled node tree will be described with reference to FIGS. 5 to 7 illustrate a normal insertion process, and FIG. 8 illustrates a root node insertion process. Since the coupled node tree is generated by the root node insertion process and the normal insertion process, the description of the node insertion process is also the description of the coupled node tree generation process.

FIG. 5 is a diagram showing the processing flow of the search process, which is the first stage of the insert process, and corresponds to the search key shown in FIG. 4 with the insert key as the search key. In step S501, the array element number of the root node is set as the search start node, and in step S510, the search process shown in FIG. 4 is executed.
Next, in step S511, the insertion key is compared with the index key obtained in step S510. If they are equal, the insertion key already exists in the coupled node tree, so the insertion fails and the process ends. If not equal, the process proceeds to the next process, that is, the process of step S516 and thereafter in FIG.

FIG. 6A is a processing flow diagram illustrating processing for obtaining a position on a tree where a leaf node having an insertion key as an index key is inserted.
In step S516, bit string comparison between the insertion key and the index key obtained in step S510 is performed by, for example, exclusive OR, to obtain a difference bit string.
Proceeding to step S517, the difference bit position that is the bit position of the first non-matching bit viewed from the higher-order 0th bit is set as the difference bit position that is the work area from the difference bit string obtained in step S516. In this process, for example, a CPU having a priority encoder can input a difference bit string to obtain a mismatched bit position. It is also possible to obtain a difference bit position by performing a process equivalent to that of the priority encoder in software.

In step S518, it is determined whether the stack pointer of the search path stack points to the array element number of the root node. If so, the process proceeds to step S524, and if not, the process proceeds to step S519.
In step S519, the stack pointer of the search path stack is returned by 1, and the array element number stacked there is taken out.
Proceeding to step S520, the array element having the array element number extracted at step S519 is read from the array as a node.
Proceeding to step S521, the discrimination bit position is extracted from the node read out at step S520.
In step S522, it is determined whether the discrimination bit position extracted in step S521 is higher than the difference bit position obtained in step S517. Here, the upper positional relationship is a position on the left side of the bit string, that is, a position where the value of the bit position is small.
If the determination result in step S522 is negative, the process returns to step S518, and is repeated until the determination in step S518 becomes affirmative or the determination in step S522 becomes affirmative. If the determination in step S522 is affirmative, the stack pointer of the search path stack is advanced by 1 in step S523, and the process proceeds to step S524.
In step S524, the array element number pointed to by the stack pointer is extracted from the search path stack and set as the array element number at the insertion position.

  In the processing described in steps S516 to S524, the bit string comparison is performed between the index key to be inserted and the index key acquired by the search in order to determine the insertion position of the node to be inserted. The relative positional relationship between the first (most significant) bit position and the discrimination bit position of the branch node stored in the search path stack is examined, and the branch node next to the branch node having the higher discrimination bit position is checked. This is the insertion position of the node into which the link destination is inserted.

  Following step S524, the process proceeds to step S525a in FIG. 6B. FIG. 6B is a process for preparing an array element for storing a leaf node holding the inserted index key and a node paired therewith.

In step S525a, the array number of an empty node is acquired from the array and set to node number [0]. Similarly, in step S525b, the array number of an empty node is acquired from the array and set to node number [1].
In step S526, the insertion key is compared with the index key obtained in step S510. When the insertion key is large, a value 1 is obtained, and when the insertion key is small, a Boolean value 0 is obtained.
Proceeding to step S527a, the array element number set to node number [i] in step S525a or step S525b when the Boolean value obtained in step S526 is set to i is set as the array element number of the leaf node. Similarly, in step S527b, the array element number set to the node number [i] in step S525a or step S525b when the value obtained by inverting the Boolean value obtained in step S526 is set as the array element number of the paired node. .

The array element number set in step S527a is the array element number of the array element in which the leaf node storing the insertion key as an index key is stored. The array element number set in step S527b is stored in the node paired with the leaf node. Of the array element to be processed.
In other words, depending on the size of the index key and the insertion key of the leaf node obtained in the previous search process, it is determined which of the paired nodes to which the leaf node holding the insertion key is stored is inserted. Is done.

Subsequent to step S527b, the process proceeds to step S528 shown in FIG.
FIG. 7 is a diagram showing a processing flow in which nodes are stored in the array elements prepared in FIG. 6B and the contents of existing nodes are changed to complete the insertion processing.

In step S528, 1 indicating the leaf node is written in the node type of the array element indicated by the array element number set in the array element number of the leaf node in step S527a, and the insertion key is written in the index key.
Next, proceeding to step S529, the array element having the array element number set as the array element number at the insertion position in step S524 is read from the array, and in step S530, the array element having the array element number set to the array element number of the pair node is read in step S529. Write the contents.
Finally, in step S531, the node type of the array element pointed to by the array element number set in step S524 is set to 0 indicating the branch node, and the difference bit position obtained in step S517 is set to the discrimination bit position. The array number set in node number [0] in step S525a is written in [0], and the array number set in node number [1] in step S525b is written in node number [1], and the process ends.

FIG. 8 is a diagram illustrating the processing flow of the entire leaf node insertion process including the root node insertion process according to an embodiment of the present invention.
In step S551, it is determined whether the array element number of the root node of the coupled node tree requested to be acquired has been registered. If registered, the normal insertion process described with reference to FIGS. 5 to 7 is performed.
If the determination in step S551 is not registered, registration and generation of a completely new coupled node tree starts.

First, in step S552, an array number of an empty node is acquired from the array. In step S554, the array element indicated by the array element number acquired in step S552, that is, the array element corresponding to the root node to be inserted, 1 indicating the leaf node in the node type and the insertion key in the index key are written. In step S556, the array element number acquired in step S552 is registered as the array element number of the root node, and the process ends.
As described above, when there is a set of index keys, the index keys are sequentially extracted from the set, and the processing of FIGS. 8 and 5 to 7 is repeated, so that the couple of the present invention corresponding to the set of index keys is performed. Obviously, a node tree can be constructed.

Next, a processing flow for deleting a leaf node including a specific index key from the address separation type coupled node tree according to the embodiment of the present invention will be described with reference to FIGS.
FIG. 9 is a diagram showing the processing flow of the search process that is the first stage of the delete process, and corresponds to the search process shown in FIG. 4 with the delete key as the search key. In step S901, the array element number of the root node is set as the search start node, and the search process shown in FIG. 4 is executed in step S910.
Next, in step S911, the deletion key is compared with the index key obtained in step S910. If they are not equal, the index key to be deleted does not exist in the coupled node tree, so the deletion fails and the process ends. If they are equal, the process proceeds to the next process, the process of step S912 and subsequent steps in FIG.

FIG. 10 is a diagram for explaining the processing flow at the latter stage of the deletion processing.
First, in step S912, it is determined whether two or more array element numbers are stored in the search path stack. The fact that two or more array numbers are not stored is, in other words, only one, and the array number is that of the array element in which the root node is stored. In that case, the process proceeds to step S918, and the node related to the array element number of the root node obtained in step S901 is deleted. In step S919, the registration of the root node array element number is deleted.

If it is determined in step S912 that two or more array numbers are stored in the search path stack, the process proceeds to step S913a, the stack pointer of the search path stack is returned by 1, the array number is extracted, and the array number of the parent node is obtained. Set as.
Next, in step S913b, the array element pointed to by the array element number of the parent node set in step S913a is read as a node, and the process proceeds to step S913c.
In step S913c, the value indicated by the node number [i] is extracted from the read node and set as the array number of the paired node. However, i is a value obtained by inverting the bit value obtained in step S407 of the search process shown in FIG. 4 called in step S910. In this process, the array element number at which the node paired with the leaf node holding the index key to be deleted is arranged.

Next, in step S914a, the contents of the array element indicated by the array element number of the paired node are read from the array, and the contents read in step S914a are written in the array element indicated by the array element number of the parent node in step S914b. In this process, a branch node that is a link source to the leaf node storing the index key to be deleted is replaced with a node that is paired with the leaf node.
Next, in step S917a, the array element indicated by the array element number obtained in step S409 of the search process shown in FIG. 4 called in step S910 is emptied, that is, the node stored in the array element is deleted. Next, in step S917b, the array element indicated by the array element number set as the array element number of the pair node in step S913c is emptied, that is, the node stored in the array element is deleted, and the process ends.

  Next, a specific example of the deletion process will be described with reference to FIGS. 11A and 11B. FIG. 11A shows an address-separated coupled node tree, a deletion key 1170, and a search path stack 310 before the deletion process. FIG. 11B shows the address-separated coupled node tree and search path stack 310 after the deletion process.

  The tree illustrated in FIG. 11A includes a root node 1110a stored in the array element having the array element number 1120, a node 1110b and a node 1111b that form a lower pair, and a node 1110d and a node 1111d that form a lower pair. The node 1110c and the node 1111c are paired.

“0” is stored in the node type 1160a of the root node 1110a, “0” is stored in the discrimination bit position 1130a, and the node number [0] and the node number [1] are 1120a and 1140a, respectively. The value of the delete key 1170 is “00100”.
“0” is stored in the node type 1160b of the node 1110b, “2” is stored in the discrimination bit position 1130b, and the node number [0] and the node number [1] are 1120b and 1140b, respectively. “1” is stored in the node type 1160b of the node 1111b, indicating that the node 1111b is a leaf node, and “10000” is stored in the index key 1151b.
“0” is stored in the node type 1160d of the node 1110d, “3” is stored in the discrimination bit position 1130d, and the node number [0] and the node number [1] are 1120d and 1140d, respectively. “1” is stored in the node type 1160d of the node 1111d, indicating that the node 1111d is a leaf node, and “00100” is stored in the index key 1151d.
In the discrimination bit positions 1160c and 1161c of the nodes 1110c and 1111c, “0” is stored, these nodes are leaf nodes, and “00010” and “00001” are stored in the index keys 1150c and 1151c, respectively. Stored.

  When an index key search is executed with the delete key 1170 using the root node 1110a as a search start node, the bit value of the bit position 0 of the delete key 1170 is 0 and the bit value of the bit position 2 is 1, so that the bold line shown in FIG. The node 1110a, the node 1110b, and the node 1111d of the arrows reach the leaf node 1111d, and the search path stack 310 stores the array numbers of those nodes. The stack pointer indicated by the thick arrow indicates the array number 1140b. pointing.

  As a result of the subsequent process of the deletion process shown in FIG. 10 after the search, the stack pointer of the search path stack 310 is returned by one as shown in FIG. 11B, and 1120a is set as the array element number of the parent node. 1120b is set as the array element number of the node. Then, the contents of the array element pointed to by array number 1120b of the opposite node (node 1110d) are overwritten by the array element pointed to by array number 1120a of the parent node (node 1120b is stored), and node 1120b is the one shown in FIG. 11B. It becomes. Further, the node indicated by the array element number 1140b is deleted, and the address separation type coupled node tree after the deletion processing is as shown in FIG. 11B.

  Next, a specific example of the insertion process will be described with reference to FIGS. 12A to 12D. FIG. 12A shows an address separation type coupled node tree, an insertion key 1270, and a search path stack 310 before insertion processing. FIG. 12B shows the address-separated coupled node tree and search path stack 310 after the insertion process.

The tree illustrated in FIG. 12A includes a root node 1210a stored in an array element having an array element number 1220, and a node 1210b and a node 1211b that form a lower pair.
“0” is stored in the node type 1260a of the root node 1210a, “0” is stored in the discrimination bit position 1230a, and the node numbers [0] and [1] are 1220a and 1240a, respectively. The value of the insert key 1270 is “00010”.
In the discrimination bit positions 1260b and 1261b of the nodes 1210b and 1211b, both “0” are stored, and these nodes are leaf nodes. “10000” and “00001” are stored in the index keys 1250b and 1251b, respectively.

  When the search of the index key shown in FIG. 5 is executed with the root node 1210a as the search start node by the insert key 1270, the bit value of the bit position 0 of the insert key 1270 is 0. The leaf node 1210b is reached by the route of the nodes 1210a and 1210b, and the index key 1250b “00001” is obtained as a search result. The search path stack 310 stores the array element numbers of these nodes, and the stack pointer indicated by the thick arrow points to the array element number 1220a.

  When the insertion key 1270 is compared with the index key 1250b by the processing shown in FIG. 6A, the insertion key 1270 is larger than the index key 1250b, and the difference bit position between them is “3”. When the stack pointer is returned by 1, the stack pointer points to the array element number 1220 of the array element in which the root node 1210a is stored, and the contents of the root node 1210a are read. Since the discrimination bit position 1230a of the root node 1210a is “0” and higher than the difference bit position “3”, the array element number 1220a is set as the array element number of the insertion position.

Next, the array number 1220b and the array number 1240b of the empty nodes are acquired from the array by the processing shown in FIG. 6B, and set as the node number [0] and the node number [1], respectively. Furthermore, the array element number 1240b set to the node number [1] is set as the array element number of the leaf node, and the array element number 1220b set to the node number [0] is set as the array element number of the counter node.

Next, by the processing shown in FIG. 7, “1” is stored in the node type 1261c of the node 1211c stored in the array element indicated by the array element number 1240b set as the array element number of the leaf node, and the insert key 1270 “00010” is stored in the index key 1251c. To do. Further, the contents of the array element pointed to by the array element number 1220a set as the array element number of the insertion position, that is, the contents of the node 1210b are written in the array element pointed to by the array element number 1220b set as the array element number of the paired node, It is assumed that the node 1210c forms As illustrated, the node type 1260c of the node 1210c is equal to the node type 1260b of the node 1210b before the insertion process, and the index key 1250c is equal to the index key 1250c before the insertion process.
Further, the node type 1260b of the array element (the node 1210b is stored) indicated by the array element number 1220a set as the array element number of the insertion position is set to a difference between “0” indicating that it is a branch node and the discrimination bit position 1230b. The bit position is written in node number [0] with 1220b and node number [1] with 1240b.
By the above insertion processing, the address separation type coupled node tree shown in FIG. 12A becomes as shown in FIG. 12B.

Next, a specific example of inserting an index key will be described with reference to FIGS. 12C and 12D. The address separation type coupled node tree shown in FIG. 12C is the same as that shown in FIG. 12B. The value of the insert key 1270 is “00100”.
When the search of the index key shown in FIG. 5 is executed using the root key 1210a as the search start node by the insert key 1270, the bit value of the bit position 0 of the insert key 1270 is 0 and the bit value of the bit position 3 is 0. For this reason, the leaf node 1210c is reached by the route of the nodes 1210a, 1210b, and 1210c indicated by the bold arrows in the figure, and the index key 1250c “00001” is obtained as a search result. The search path stack 310 stores the array element numbers 1200, 1220a, and 1220b of those nodes, and the stack pointer indicated by the thick arrow points to the array element number 1220b.

When the insertion key 1270 and the index key 1250c are compared by the process shown in FIG. 6A, the insertion key 1270 is larger than the index key 1250c, and the difference bit position between them is “2”. When the stack pointer is returned by 1, the stack pointer points to the array element number 1220a of the array element in which the node 1210b is stored, and the contents of the node 1210b are read out. Since the discrimination bit position 1230b of the node 1210b is “3”, which is not higher than the difference bit position “3”, the stack pointer is returned by one.
Then, since the stack pointer indicates the array element number 1220, that is, the array element number of the root node 1210a, the contents of the root node 1210a are read out. The discrimination bit position 1230a of the root node 1210a is “0”, which is higher than the difference bit position “3”, so that the stack pointer is incremented by 1 to extract the array element number 1220a, and the array element number 1220a is set as the array element number of the insertion position. .

Next, the array number 1220d and the array number 1240d of the empty nodes are acquired from the array by the processing shown in FIG. 6B, and set as the node number [0] and the node number [1], respectively. Furthermore, the array element number 1240d set in the node number [1] is set as the array number of the leaf node, and the array element number 1220d set in the node number [0] is set as the array number of the counter node.
Next, by the process shown in FIG. 7, “1” is stored in the node type 1261d of the node 1211d stored in the array element indicated by the array element number 1240d set as the array element number of the leaf node, and the insert key 1270 “00100” is stored in the index key 1251d. To do. Further, the contents of the array element pointed to by the array element number 1220a set as the array element number of the insertion position, that is, the contents of the node 1210b are written in the array element pointed to by the array element number 1220d set as the array element number of the pair node, It is assumed that the node 1210d forms As illustrated, the node type 1260d of the node 1210d is the node type 1260b of the node 1210b before the insertion process, the discrimination bit position 1230d is the discrimination bit position 1230b, the node number [0] 1220d is the node number [0] 1220b, Node number [1] 1240d is equal to node number [1] 1240b.
Further, the node type 1260b of the array element (node 1210b is stored) pointed to by the array element number 1210a set as the array element number of the insertion position is set to a difference between “0” indicating a branch node and the discrimination bit position 1230b. In bit position “2”, array number 1220d is written in node number [0], and array number 1240d is written in node number [1].
By the above insertion processing, the address separation type coupled node tree shown in FIG. 12C becomes as shown in FIG. 12D.

Although the best mode for carrying out the present invention has been described in detail above, it is obvious to those skilled in the art that the embodiment of the present invention is not limited thereto and can be variously modified.
In addition, it is obvious that the bit string search device of the present invention can be constructed on a computer by a storage means for storing a coupled node tree and a program for causing the computer to execute the processing shown in FIG.
Furthermore, the index insertion method of the present invention can be realized by the program that causes the computer to execute the index insertion process shown in FIGS. 8 and 5 to 7 and its equivalent, and the deletion process shown in FIGS. 9 and 10. It is also clear that the index deletion method of the present invention can be realized by a program that causes a computer to execute the equivalent. With these programs, a means for identifying a branch node and a leaf node, a means for linking to one of a pair of nodes according to the discrimination bit position of the branch node, and the like are realized on the computer.
Therefore, the program and a computer-readable storage medium storing the program are included in the embodiment of the present invention. Furthermore, the data structure of the coupled node tree of the present invention is also included in the embodiment of the present invention.

It is a figure which shows an example of the Patricia tree used by the conventional search. It is a figure explaining the structural example of the address separation type coupled node tree stored in the arrangement | sequence. It is a figure which shows notionally the tree structure of an address separation type coupled node tree. It is a figure explaining the hardware structural example for implementing this invention. It is a flowchart which shows the search process in one Embodiment of this invention. It is a figure which shows the processing flow of the search process which is the front | former stage of the insertion process in one Embodiment of this invention. It is a figure explaining the processing flow which prepares the array element for the node pair to insert in the insertion process in one Embodiment of this invention. It is a figure explaining the processing flow which prepares the array element for the node pair to insert in the insertion process in one Embodiment of this invention. It is a figure which shows the processing flow which calculates | requires the position which inserts a node, writes the content of each node, and completes insertion processing. It is a figure explaining the processing flow of the whole insertion process of the leaf node including the insertion process of a root node in one Embodiment of this invention. It is a figure which shows the processing flow of the search process which is the front | former stage of the deletion process in one Embodiment of this invention. It is a figure explaining the processing flow of the latter part of deletion processing in one embodiment of the present invention. It is a figure which shows the example of an address separation type coupled node tree before a deletion process. It is a figure which shows the example of an address separation type coupled node tree after a deletion process. It is a figure which shows the example of an address separation type coupled node tree before insertion processing. It is a figure which shows the example of an address separation type coupled node tree after an insertion process. It is a figure which shows another example of an address separation type coupled node tree before insertion processing. It is a figure which shows another example of an address separation type coupled node tree after an insertion process.

Explanation of symbols

10, 12, 13 Array number 100 Array 101, 112, 113 Node 102, 114, 117 Node type 103, 115 Discrimination bit position 104a, 116a Node number [0]
104b, 116b Node number “1”
118 Index key 301 Data processing unit 302 Central processing unit 303 Cache memory 304 Bus 305 Main storage unit 306 External storage unit 307 Communication unit 308 Data storage unit 309 Array 310 Search path stack

Claims (12)

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 between leaf nodes,
The root node is a node representing a starting point of the 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 a discrimination bit position of a search key for performing a bit string search, position information of one node of the node pair, and position information of the other node, and the leaf node includes an index key composed of a bit string to be searched. , With address-separated coupled node tree,
Arbitrary nodes of the address-separated coupled node tree are used as search start nodes, and in the branch node, the position information of the one node or the other according to the bit value of the search key of the discrimination bit position included in the branch node The index key included in the leaf node is selected by repeating the process of sequentially linking to either node of the node pair based on the selected position information until reaching the leaf node. A bit string search device characterized by using a search result key as a search result by the search key of an arbitrary subtree of the address-separated coupled node tree having a search start node as a root node.   The address-separated coupled node tree is stored in an array, and the position information of the one node and the position information of the other node are array element numbers of array elements of the array in which the node is stored, and the search The array element number of the array element storing the start node and the array element number of the array element storing the link destination node from the search start node to the leaf node are sequentially held in the stack. Item 2. The bit string search device according to Item 1. 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 between leaf nodes,
The root node is a node representing a starting point of the 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 a discrimination bit position of a search key for performing a bit string search, position information of one node of the node pair, and position information of the other node, and the leaf node includes an index key composed of a bit string to be searched. In the bit string search method using the address-separated coupled node tree,
Arbitrary nodes of the address-separated coupled node tree are used as search start nodes, and in the branch node, the position information of the one node or the other according to the bit value of the search key of the discrimination bit position included in the branch node The index key included in the leaf node is selected by repeating the process of sequentially linking to either node of the node pair based on the selected position information until reaching the leaf node. A bit string search method, wherein a search result key that is a search result by the search key of an arbitrary subtree of the address-separated coupled node tree having a search start node as a root node is used.   The address-separated coupled node tree is stored in an array, and the position information of the one node and the position information of the other node are array element numbers of array elements of the array in which the node is stored, and the search The array element number of the array element storing the start node and the array element number of the array element storing the link destination node from the search start node to the leaf node are sequentially held in the stack. Item 4. The bit string search method according to Item 3. A tree used for a bit string search comprising a root node and a branch node and a leaf node or a node pair between branch nodes or between leaf nodes, wherein the root node is a node representing a starting point of the tree, When there is one node, the leaf node is used. When there are two or more nodes in the tree, the branch node is used. The branch node is used to identify a bit position of a search key for performing a bit string search and a link destination node pair. Including the position information of one node and the position information of the other node, the leaf node includes an index key composed of a bit string to be searched,
Arbitrary node of the tree is set as a search start node, and the position information of the one node or the position information of the other node is selected in the branch node according to the bit value of the search key of the discrimination bit position included in the branch node Then, by sequentially linking to either node of the node pair based on the selected position information until reaching the leaf node, the index key stored in the leaf node is used as the search start node as the root node. A leaf node including an index key composed of a desired bit string is inserted into an address-separated coupled node tree configured to be a search result key that is a search result by the search key of an arbitrary subtree of the tree In the index key insertion method,
The index key is used as the search key, the root node is used as a search start node, the corresponding leaf node is searched from the address-separated coupled node tree, and the branch node of the link path that reaches the leaf node, and The position information where leaf nodes are arranged is sequentially stored,
A size comparison and a bit string comparison are performed between the search key and an index key included in the corresponding leaf node,
A leaf node including an index key inserted according to a relative positional relationship between a leading bit position that becomes a different bit value in the bit string comparison and a discrimination bit position of a branch node arranged at a position indicated by the sequentially stored position information; Determine the insertion position of the node pair consisting of the other node,
Determining which node of the inserted node pair the leaf node containing the index key to be inserted according to the magnitude relationship;
An index key insertion method characterized by the above.   The address-separated coupled node tree is stored in an array, and the position information of the one node and the position information of the other node are array element numbers of array elements of the array in which the node is stored, and the search The array element number of the array element storing the start node and the array element number of the array element storing the link destination node from the search start node to the leaf node are sequentially held in the stack. Item 6. The index key insertion method according to Item 5. A tree used for a bit string search comprising a root node and a branch node and a leaf node or a node pair between branch nodes or between leaf nodes, wherein the root node is a node representing a starting point of the tree, When there is one node, the leaf node is used. When there are two or more nodes in the tree, the branch node is used. The branch node is used to identify a bit position of a search key for performing a bit string search and a link destination node pair. Including the position information of one node and the position information of the other node, the leaf node includes an index key composed of a bit string to be searched,
Arbitrary node of the tree is set as a search start node, and the position information of the one node or the position information of the other node is selected in the branch node according to the bit value of the search key of the discrimination bit position included in the branch node Then, by sequentially linking to either node of the node pair based on the selected position information until reaching the leaf node, the index key stored in the leaf node is used as the search start node as the root node. Index key deletion that deletes a leaf node including an arbitrary index key from an address-separated coupled node tree configured to be a search result key that is a search result by the search key of an arbitrary subtree of the tree In the method
Search the address-separated coupled node tree using the index key as the search key and the root node as a search start node,
Write the contents of the node paired with the leaf node storing the search result key to the branch node that is the link source of the leaf node,
Delete the leaf node,
An index key deletion method characterized by that. The address-separated coupled node tree is stored in an array, and the position information of the one node and the position information of the other node are array element numbers of array elements of the array in which the node is stored, and the search The array element number of the array element storing the start node and the array element number of the array element storing the link destination node from the search start node to the leaf node are sequentially held in the stack. Item 8. The index key deletion method according to Item 7.   A program for causing a computer to execute any one of the bit string search method according to claim 3 or 4, the index key insertion method according to claim 5 or 6, or the index key deletion method according to claim 7 or 8 is stored. Computer-readable storage medium.   A program for causing a computer to execute any one of the bit string search method according to claim 3 or 4, the index key insertion method according to claim 5 or 6, or the index key deletion method according to claim 7 or 8. A tree-like data structure used for bit string search,
A tree used for a bit string search comprising a root node and a branch node and a leaf node or a node pair between branch nodes or between leaf nodes, wherein the root node is a node representing a starting point of the tree, The node is a leaf node when there is one node, and the branch node when there are two or more nodes in the tree. The branch node is one node of a discrimination bit position and a node pair of a search key for performing a bit string search. The position information of the other node and the position information of the other node, the leaf node includes an index key composed of a bit string to be searched,
Arbitrary node of the tree is set as a search start node, and the position information of the one node or the position information of the other node is selected in the branch node according to the bit value of the search key of the discrimination bit position included in the branch node Then, by sequentially linking to either node of the node pair based on the selected position information until reaching the leaf node, the index key stored in the leaf node is used as the search start node as the root node. A data structure capable of executing a search process using a search result key that is a search result by the search key of an arbitrary subtree of the tree. The data structure is stored in an array, and the position information of the one node and the position information of the other node are array numbers of array elements of the array in which the node is stored. The data structure described.

Images