JP3199166B2 - Network type data structure address assignment and access method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to online help in the field of computers (On Line Help).
Composition, Japanese FEP (Front End Processes)
SOR) and IME (Input Method Edit)
or), directory structure (including shared directory)
Unified information, unified information of network structure network and program structure network, unified information of random walk, execution history at the time of profile, version management information and configuration management information of programs and documents, and all programs that apply list structure (LISP And data that can have multiple parent data, such as applications to programming languages such as Prolog), knowledge bases, scheduling and workflow, and network-type databases (structures that exist between equivalent data such as family tree). The present invention relates to a network type data structure address assignment / access method for realizing address assignment and access to a storage area such as a file or a memory relating to data of a network type data structure which can be applied as a substitute for the “structure or list structure”. What
Here, in the present invention, “address of storage area
“Assignment” refers to the actual data array and
And adjacency array (data of network type data structure)
Initialization processing of both arrays for expressing
Management and batch deletion processing.

[0002]

2. Description of the Related Art Documents showing the prior art relating to the present invention include, for example, "Information Mathematics Seminar, Information Structure (above), Data Structure and Graph Algorithm (by Takao Asano, Nihon Hyoronsha)", p122-p128. is there.

[0003] Hereinafter, a conventional technique will be specifically described.

[0004] Various data structures are expressed using an array or a list structure. Here, the array refers to a data structure sequence having a fixed length and continuous on a memory. Further, the list structure refers to a data structure having data and information (pointer) of the adjacent relationship between the data. For example, arrays are used to implement tree data with a fixed depth. On the other hand, the list structure is a circular data structure centered on an m-tree having no logically limited depth, or a network (physical meaning is given by attaching quantitative characteristics called weights or capacities to branches and nodes of a graph. ) To represent more complex data structures (e.g.

In the conventional data structure expression method, as described above, a network type data structure (a data structure capable of expressing a network) is realized using a list structure.

[0006] For a database only, NDL is known as a language for realizing a network-type data structure. NDL is an NDL database (ND
A language that defines the definition and operation of B). This is N
A schema definition language for logically describing a DB, and an NDB
And a sub-schema definition language that logically describes a part that can be used by the user (a part defined in the schema definition language of NDB is a schema, and is defined in the sub-schema definition language). Part is a subschema). In the NDB, a parent-child set, a recursive parent-child set, a singular parent-child set, a temporary parent-child set, and the like exist as data structures, and are realized by classifying the expression of the network type data structure into these forms. Although this scheme implements a logical, network-type data structure, the complexity of the algorithms that make use of it is not significantly reduced, and therefore its use is limited to databases. Therefore, the following “problem to be solved by the invention” does not refer to this method.

[0007]

The above-mentioned prior art (conventional data structure expression method) has the following problems.

The first problem is that the expression of a general network type data structure is complicated.
Along with that, "the readability at the time of coding (the readability of the source (source program)) deteriorates."
That's what it means.

The reason for such a problem is that, in the case of an array, an affiliation relationship can be expressed like a relational data type, but an adjacency relationship cannot be expressed, and in the case of a list structure, certain data includes a plurality of reference data. This is because, in the case of linking to a list of addresses, the list of addresses of the reference destination must be represented by a list structure, and as a result, the address is acquired by the pointer of the pointer and the reference destination data is recognized. That is, the identifier representing the pointer can be freely determined, and as a result,
Because it is expressed in a multi-structure, the readability of the source is significantly impaired. As a countermeasure for the above-mentioned problem in the conventional technique, one data area is made to have a variable length, a data structure in which a reference address is continued in addition to data, and a row of the address ends when a specific code is detected. There is a method to adopt.

[0010] The second problem is that the expression of the network-type data structure necessitates waste of a storage area.

[0011] The reason why such a problem exists will be described below with reference to set symbols in order to make it easier to understand.

For the set S, the number of elements of S is | S |. Also graph the data and the adjacency between the data:
A set of data (points) is represented by V, and a set of adjacent relations (sides) between data is represented by E (E⊆V × V).

At this time, the graph is expressed as G = (V, E).

In the case of the list structure, as mentioned in the first problem, two pointers (pointer and pointer pointer) are used to indicate the relationship between one piece of data. (The number of pointers is | V |, the number of pointer pointers is | E |, and a total of | V | + | E | cells is required). V | + | E | cells are required.
However, the addition + is not strict because the size of each data is not taken into account.)

[0015] In addition, since a pointer of a set of pointers can recognize only one direction, a double storage area is required to recognize two directions. Therefore, even in the workaround for the first problem in the prior art referred to in the description of the first problem, the cell is | V | +
| E | pieces, but in the case of bidirectional (| E |
Data area.

In view of the above, it is an object of the present invention to express a network simply and with excellent readability, without exceeding the list structure in the amount of source description, and being smaller than the list structure in the amount of storage. Network type data structure address assignment that can realize network type data structure
To provide an access method.

As a result, the productivity and maintainability of the source description can be improved, the consumption of storage resources can be suppressed, and the storage resources can be reused accordingly.

[0018]

[Means for Solving the Problems]

(1) Theoretical Basis of the Present Invention First, the basic concept of implementing (expressing) a network-type data structure by the network-type data structure address assignment / access method of the present invention will be described.

First, a network-type data structure is recognized as a graph ("network" is a concept that includes information such as numerical values in "graph"), each data is interpreted as a point of the graph, and the adjacency between data is interpreted. Is interpreted as an edge of the graph.
Here, the side of the graph is a directed side having a data reference source as a start point and a data reference destination as an end point.

Then, a data reference destination and a reference source are defined based on the information on the directed side. If it is possible to uniquely specify the data reference source, the data reference destination, and the like from the side information, data access is possible if only this side information is present in addition to the actual data. That is, since the process does not start from the data of the reference source as in the conventional method, information on the reference source can be omitted from the storage area. The same can be said for the reference destination, but it can be realized if there is a storage area only for the information of the actual data and the information of the adjacency between the data. Also,
Since the method of the present invention does not depend on the form of adjacency between data, an arbitrary data structure such as a network can be designed.

Next, a method for defining a directed side and a method for specifying a data reference source and a reference destination are specifically realized.

The position of actual data is specified by a relative address. On the other hand, the directed side is a calculation result of a paired function obtained from the address of the reference source data and the address of the reference destination data. Here, a pair function refers to a set of three functions (P, Q, R) satisfying the following definition (Equation (1)
a), (1b), and (1c)). In the following description, when Expressions (1a), (1b), and (1c) are collectively shown, they are expressed as “Expression (1)” (the same applies to other expressions).

(Equation 1)

Here, for variables x, y and z,
The following identity relationship holds (see equations (2a), (2b), and (2c)).

(Equation 2)

That is, z: x = 1: many (one-to-many correspondence) and z: y = 1: many, but z: (x,
y) = 1: 1 (one-to-one correspondence).

FIG.

It goes without saying that the symbols indicating functions and variables for expressing the paired function are not limited to P, Q, R, x, y and z.

From the above, the following theorem (theorem showing order isomorphism or monotonicity) is obtained.

[Theorem] Graph G = (V, E) (V: point set, E: edge set), pair function (P, Q, R) (according to equation (1)), finite subset M of integers, N (| M | = | V |, | N | = | E |). At this time, the bijection that makes the point (element of V) correspond to the numerical value 1: 1

(Equation 3) Is a bijection that makes the edge (element of E) correspond to the numerical value 1: 1

(Equation 4) Satisfies the following relationship:

(Equation 5)

Hereinafter, the principle and implementation of the present invention will be described using this theorem.

In general, a side can be expressed as (A, B) with respect to a start point A and an end point B (A → B in the figure). Here, A and B are uniquely represented by numerical values, interpreted as x = A and y = B and substituted into the function R, and z = C = R (A,
When B) is obtained, from equations (2b) and (2c), C
Is unique to both A and B (A = P (C) and B = Q (C)), and C can be uniquely defined as directed side information, that is, adjacent relation. Therefore, only the information of C needs to be stored in the storage area. Further, since every graph (network) is composed of points and edges connecting them, the configuration can be defined only by the number of edges in any form. If A and B are the addresses of the data of the reference source and the data of the reference destination, they are unique, and therefore C is also unique. In addition, it is possible to obtain the value in both A and B directions.

Therefore, as a method of storing data, real data is defined by an array, and the entire adjacency between data is expressed by a C array obtained by a pair function based on a relative (or absolute) address in the array. Represent. When the whole of the actual data is represented by V and the whole of the adjacency relation between the data is represented by E, the arrangement of the actual data consumes | V | data areas, and the arrangement of the adjacency relation is | E | Consume.

Algorithms can be classified as shown below in accordance with the case.

Searching for All Items (Retrieval of All Actual Data) In the case of searching for all items, all of the actual data is searched for, ignoring the array of the adjacent relationship between data.

Partial Search In a search for all reference destinations from specific data, P (z)
Since the inverse function of Q (z) and Q (z) is a multi-valued function, the reference source searches for the solution of the equation (1b) for the edge information (z) as the specific data from all the adjacencies between data, and the solution refers to the solution. In the case of matching with the source, the reference destination is obtained by Expression (1c). (The search of the reference source uses the reverse algorithm. In the case of bidirectional, the treatment of Expression (1b) and Expression (1c) is appropriately performed.) Just change it).

Batch Join Joining network-type data structures of the same data type (A
PPEND),

(Equation 6) Interpret as Therefore, in the collective joining, it is sufficient to simply join the sequences of the adjacent relationship (if necessary, add the adjacent relationship between G ₁ and G ₂ ).

Batch Deletion In the case of deletion (DELETE) of a part (network type data structure) from the network type data structure,

(Equation 7) Interpret as Therefore, even in mass delete simply (also deleted actual data if necessary) to it saves the adjacency of the corresponding part G ₂ from the sequence of adjacency.

In the above description of the algorithm classification, the graph is set to G _i = (V (G _i ), E (G _i )) (i: 1 or 2, V (G _i ): graph G _i Is a real data set, and E (G _i ) is a set of edges of the graph G _i and substantially a set of adjacency relations. As can be seen from the above and in the above, the data is present as an address and has nothing to do with the presence or absence of actual data at the time of combining / deleting.

The number of pairs of functions is not one, but is infinitely countable if the domain and range of the function R are integer values.
The present invention is intended for all the cases satisfying the expression (1) and does not specify the type (however, in general, since the address is an integer value, an integer value is used to directly use this value. And).

When one pair function is found, there are countless infinite number of the same kind of pair functions. This is because another pair function can be transformed into countable infinity by some formula transformation.

Using (P, Q, R) as a pair function, the following formulas (5) and (6) show typical formula variants (formula variants 1 and 2).

[Formula Modification 1]

(Equation 8)

[Equation 2]

(Equation 9)

When actually configuring the storage area in this manner, there is a case where attention must be paid.

Since the paired function cannot form the domain of the function R unless the domain is always paired, the information of the start point and the end point cannot recognize that the pair does not exist.
This is fine because there are no edges in mathematics,
The problem is that the end cannot be recognized by the algorithm.

To address this problem, a value: A
Is defined as an unpaired state for all points, and its value A
Is deviated from the range of the function R. In the case of performing this contrivance, the domain of the adjacent relationship is as shown in Expression (7). In order to set the pair function in this way, the parallel movement of Expression (5) may be applied.

[0046]

(Equation 10)

If A is to be interpreted as side information,
It is virtual directed side information adjacent to all points and adjacent to all points. Therefore, as a procedure of the storage area configuration, an appropriate pair function is searched for, the value of A is determined, and the equations (5) to (7) can be specifically set and designed.

Finally, specific examples of pair functions are shown in the following equations (8) and (9). In these two examples, the value to be A in both cases is 0.

[Equation 11]

(Equation 12)

However, in equations (8) and (9), F
(Z) satisfies the following equation (10) ([X] is a real number X
Means the largest integer not exceeding).

F (z) = [(1/2) {1+ (8z-7) ^1/2 }] (10)

The equation (9) is expressed by the famous Cantor (Cant).
(or) is an expression showing a pair function.

(2) Configuration of the present invention The network type data structure address assignment / access method of the present invention provides a network type data structure address assignment for realizing address assignment and access to data of a network type data structure in a storage area. In the access method, the storage area for storing the data of the network type data structure by the real data array (point of the network) and the adjacency relation array (directed side of the network), and a storage area for address assignment of the network type data structure. A pair consisting of functions P, Q, and R that is used as direction information and satisfies z = R (x, y), x = P (z), and y = Q (z) for variables x, y, and z A paired function routine indicating a function (P, Q, R) and the storage using a paired function of the paired function routine Address allocating means for allocating an address of a network-type data structure in an area, and access means for accessing (retrieving) data of the network-type data structure in the storage area using a pair function of the pair function routine. .

In the network type data structure address assignment / access method of the present invention, the terminal symbol of the adjacent relation array in the storage area is "a value that cannot be taken as the value of the function R in the pair function (P, Q, R)". It can be realized by: In this specification, the “terminal symbol” means the end of the array.

Further, in the network type data structure address assignment / access method of the present invention, Cantor's pair function can be adopted as an example of the pair function in the pair function routine.

[0055]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, general embodiments of the present invention will be described in detail with reference to the drawings.

FIG. 1A is a block diagram showing the configuration of an embodiment of a network type data structure address assignment / access method according to the present invention.

The network type data structure address allocation / access method includes a storage area 10 including a real data array 11 and an adjacency array 12, a data processing routine 20 including an address allocation unit 21 and an access unit 22, a paired function routine. 30. The data processing routine 20 and the function routine 3
By 0, an application (application program) is formed.

FIG. 1B is a diagram showing the configuration of the storage area 10. The storage area 10 includes a real data array 11 that holds elements of a set V of real data, and an adjacency relation array 1 that holds elements of a set E of adjacency of a network type data structure.
2 is included. The contents of the real data array 11 and the adjacency relationship array 12 shown in FIG. 1B correspond to the contents of FIGS. 7A and 7B described later. Here, it is assumed that the base value of the relative address in the real data array 11 and the adjacent relationship array 12 is 1 (usually 0, but this is set to facilitate discussion). Note that resetting the base value of the relative address to 0 is easy from equation (5).

The storage area 10 is realized by an addressable memory, file, or the like, and may be of any type. The actual data array 11 may be a normal array, but the adjacency relationship array 12 requires a special device in defining the end of the data. Since the adjacency is numerical data, the terminal symbol is realized by a specific numerical value. For example, A (function R) of a specific value defined by the above equation (7)
Can not be used as a terminal symbol, and the end of the data of the adjacent relation array 12 can be defined. The end of the real data array 11 is defined by NULL (information indicating empty).

FIGS. 2A and 2B are tables showing possible values of x, y, and z in a specific example of the paired function (P, Q, R) in the paired function routine 30. is there. That is, the horizontal axis x = P (z) and the vertical axis y = Q
It is a figure showing the value of z = R (x, y) with respect to (z).
Thus, a paired function with integers as the domain and range is
You can easily represent a table without having to calculate it just by deciding how to arrange the values.

The table shown in FIG. 2A is a list based on the equation (8), and the table shown in FIG.
It is a list | wrist based on (Cantor's pair function).

The paired functions are shown in FIGS. 2 (a) and 2 (b).
Not limited to the above, a large number is known as described above, and a unique data system suitable for the purpose can be defined for each of them.

When the value of z for x = 3, y = 5 is calculated based on equation (8), z = R (3,5) = 9. Looking at the list in FIG. 2A, it is found that z = 3 and y = 5.
Is 9 (see the underlined x, y, and z values in FIG. 2 (a)).

Further, based on the equation (9), x = 3, y = 5
Calculating the value of z with respect to gives z = R (3,5) = 24. Looking at the table of FIG. 2 (b), the value of z for x = 3, y = 5 is certainly 24 (the underlined x, y, and z of FIG. 2 (b)). See values).

Conversely, if z = 7, then in equation (8), x
= P (7) = 1, y = Q (7) = 5. If these values correspond to the list shown in FIG. 2A, they certainly match (see the values of x, y, and z surrounded by a circle in FIG. 2A).

If z = 7, then in equation (9), x
= P (7) = 1 and y = Q (7) = 4. If these values correspond to the list shown in FIG. 2B, they certainly match (see the values of x, y, and z surrounded by a circle in FIG. 2B).

FIGS. 3 to 6 are flowcharts showing the processing algorithm of the data processing routine 20 in different cases.
These flowcharts correspond to the four algorithms described above in the section "Means for Solving the Problem".

FIG. 3 is a flowchart showing a processing algorithm in the case of all-item search. This processing includes a relative address base value setting step 301 and an actual data reading step 30.
2, an actual data empty determination step 303, an actual data extraction step 304, and a relative address increase step 305.
Consists of

FIG. 4 is a flowchart showing a processing algorithm in the case of a partial search. This processing includes a relative address base value setting step 401 and an adjacent relation reading step 40.
2, an adjacency relationship A determination step 403, an x value setting step 404, an x value reference source match determination step 405,
y value setting step 406 and actual data extracting step 4
07 and a relative address increment step 408.

FIG. 5 is a flow chart showing a processing algorithm in the case of batch combination. This processing is performed in L setting step 5
01, actual data addition step 502, relative address base value setting step 503, G2 adjacency A determination step 504, z value setting step 505, G1 adjacency last addition step 506, and G1 adjacency last. An update step 507 and a G1G2 adjacency addition definition step 508 are included.

FIG. 6 is a flowchart showing a processing algorithm for batch deletion. This processing includes a G2 actual data deletion step 600 and a relative address base value setting step 6
01, G2 adjacency relation A determination step 602, z value setting step 603, z ′ value setting step 604, G
One adjacency last part A setting step 605, zz 'match determination step 606, and G1 adjacency replacement step 60
7

FIGS. 7A and 7B are diagrams for explaining the operation of the network type data structure address assignment / access method according to the present embodiment.

Next, the operation of the network type data structure address assignment / access method of this embodiment will be described.

First, the operation during the initial setting processing of the storage area 10 by the address allocating means 21 will be described.

In this case, the address assigning means 21
Sets the real data array 11 and the adjacency relationship array 12 as shown in FIG. 1B in the storage area 10 based on the theoretical basis described in the above-mentioned “Means for Solving the Problem”.

For example, as shown in FIG.
V | = 6, the number of directed sides | E | = 7, a network-type data structure represented by a directed graph ", as an example, the actual data array 11 having the contents as shown in FIG. The relation array 12 is set. At the time of initialization, the end of the real data array 11 is defined by null (NULL), and the end of the adjacency array 12 is defined by the terminal symbol A.

The information indicating the adjacent relationship stored in the adjacent relationship array 12 in FIG. 1B, for example, “α → β” is
This information indicates that there is an adjacency relationship between α and β. Specifically, the relative address “1” of the real data α and the relative address “2” of the real data β in the real data array 11 are Information shown in order is conceivable.

FIG. 7 (b) shows a set {ε, {} of the end point of the directed side having the point γ included in V as the start point of the adjacent relation.
Expressions and subgraphs of the set {γ, δ} of the starting point of the directed side having the point ε as the end point of the adjacency are shown. In the access to the storage area 10 set as described above, a search is performed using the concept of such a set (detailed processing contents will be described later).

Second, the operation at the time of the all-item search process by the access means 22 will be described.

This processing corresponds to the algorithm in the above-mentioned “means for solving the problem”.

This processing algorithm is not enough to search all the actual data in all the searches (tr
ival) case, and does not use the adjacent relationship array 12 at all. It should be noted that the actual data of the search result extracted in the all-item search process is subjected to display and rewrite processing in the data processing step of the data processing routine 20.

At the time of all-item search processing, the access unit 22
Performs the following processing (see FIG. 3).

A base value (0 or 1; 1 in FIG. 1B) is set in the relative address (i) (step 30).
1).

The i-th real data of the real data array 11 in the storage area 10 (the real data specified by the absolute address and the relative address i of the head area of the real data array 11) is read (step 302). Is empty (NUL
L) is determined (step 303).

If it is determined in step 303 that "the actual data is empty", it is recognized that all the actual data has been read, and the process is terminated.

If it is determined in step 303 that the actual data is not empty, the actual data is taken out (step 304), and 1 is added to the value of the relative address (i) (step 305). (I)
If the base value of is 1, the number of loops is i at this time.)

The actual data extracted in step 304 is subjected to predetermined data processing (data reference, data update, etc.) in the data processing routine 20.

Third, the operation at the time of the partial search processing by the access means 22 will be described.

This processing corresponds to the algorithm in the above-mentioned “means for solving the problem”.

This processing algorithm is an algorithm for searching for adjacent data using certain data as a reference source or certain data as a reference destination. In this algorithm, x = P (z) and y = Q (z) are respectively calculated from a given adjacency (z), and this x
If y and y exist, it is recognized that z is one of the solutions of the inverse function P ^-1 (x) and the inverse function Q ^-1 (y) (the solution of the inverse function is not limited to one). By repeating this algorithm, even between points (data) that are not directly adjacent,
The desired data can be reached in a few steps.

At the time of the partial search processing, the access unit 22
Performs the following processing (see FIG. 4).

The base value is set to the relative address (i) (step 401).

The i-th adjacency of the adjacency array 12 of the storage area 10 (adjacency specified by the absolute address and the relative address i of the head area of the adjacency array 12) is read (step 402). It is determined whether (i-th adjacent relationship) is A (terminal symbol) (step 403).

If it is determined in step 403 that "the adjacent relationship is A", it is recognized that the adjacent relationship no longer exists, and the process is terminated.

If it is determined in step 403 that "the adjacent relationship is not A", x = P (zi) is set (step 404), and it is determined whether or not x matches the reference source (step 405). ). Note that zi indicates “i-th adjacent relationship”.

If it is determined in step 405 that "x matches the reference source", y = Q (zi) is calculated (step 406), and the real data having the yth relative address is stored in the real data array 11. Take it out (step 407).

If it is determined in step 405 that “x does not match the reference source” or if the processing in step 407 is completed, the value of the relative address (i) of the adjacent relationship is set to 1
Is added (step 408), and control is returned to step 402 (if the base value of i is 1, the number of loops is i at this point).

Fourth, the operation of the address allocating means 21 at the time of the collective combining process will be described.

Note that the collective combining process and the collective deleting process described below have the same mathematical concept, as mentioned above. However, because the way of expression on the machine (computer) is not a mathematical concept of address,
Both processes have different algorithms (that is, the difference between arrays and sets). Different data is allocated to different memories, but when changing / deleting one data, only one memory space is used. In other words, in the case of connection, the memory space is separated, and the relative address starts from the base value. However, in the case of deletion, the address is a serial number since there is only one data structure.
Therefore, the processing procedure of both processes is changed.

Now, the algorithm of the batch join is as follows.
After linking the real data of the two network-type data structures, in consideration of the fact that the relative address of the data on the linking side (G2) changes, the adjacent relationship is recalculated, and the data on the linking side (G1) is recalculated. Add to the adjacency. When an adjacency relationship is further defined between two combined data, the additional definition is performed last.

That is, the address allocating means 21 performs the following processing (see FIG. 5).

The last relative address of G1 is set to L (step 501), the actual data of G2 is added to the actual data of G1 (step 502), and the base value is set to the relative address (i) (step 502). 503).

Next, it is determined whether or not the i-th adjacent relationship of G2 is A (step 504).

If it is determined in step 504 that the “i-th adjacent relationship of G2 is not A”, the value of the adjacent relationship is set to z (step 505), and R (P (z) + L,
Q (z) + L) is added to the last part of the adjacency of G1 (step 506), the last part of the adjacency of G1 is updated (step 507), and control is returned to step 504 (the base value of i is 1). In this case, the number of loops is i at this point.) Even if the last part of the adjacent relationship of G1 is updated in step 507, the value of L remains unchanged.

If it is determined in step 504 that the “i-th adjacent relationship of G2 is A”, the adjacent relationship between G1 and G2 is additionally defined (step 508), and the process is terminated.

Fifth, the operation at the time of the batch deletion process by the address allocating means 21 will be described.

In the batch deletion algorithm, first, the actual data to be deleted (G2) is deleted (G1).
(Step 60 in FIG. 6)
0). However, basically, if the adjacent relationship is deleted, access using the adjacent relationship becomes impossible, so that the deletion process of step 600 is not an absolutely necessary process. It can be said that it is better not to perform the deletion process in that it is better to leave the actual data without deleting it, so that it can be reused later. In this case, the end determination of the actual data (see step 303 in FIG. 3) fails. Therefore, it is more appropriate to perform the deletion process. Also, in some cases, when only the adjacency to be deleted is known, the actual data cannot be easily deleted (if necessary, it is necessary to determine data that is completely separated from the adjacency to be deleted. The algorithm is not in FIG. 6). From this point as well, it can be said that the deletion processing in step 600 is not necessary (optional processing) (this processing is referred to as “step 60”).
The fact that “Step 600” is used instead of “1” is based on the above-mentioned viewpoint).

In the batch deletion algorithm, the adjacency relationship is deleted after the above-mentioned actual data deletion process, which is an optional process, and one data at the end of the adjacency is deleted every time the adjacency relationship is reduced by one. Reduction processing is performed.

That is, the network type data structure address assigning means 21 performs the following processing (see FIG. 6).

As described above, as an optional process, the actual data of G2 is deleted from the actual data of G1 (step 60).
0).

The base value is set to the relative address (i) (step 601).

Next, it is determined whether or not the i-th adjacent relationship of G2 is A (step 602).

If it is determined in step 602 that "the i-th adjacent relation of G2 is not A", the value of the adjacent relation is set to z (step 603), and the value of the last part of the adjacent relation of G1 is changed to z. z 'is set (step 604), A is set at the end of the adjacency of G1 (step 605), and it is determined whether z and z' match (step 60).
6).

If it is determined in step 606 that "z and z 'do not match", the cell of z having an adjacent relationship of G1 (the array element of the adjacent relationship array 12) is replaced with z' (step 607). Then, control is returned to step 602 (when the base value of i is 1, the number of loops is i at this point).

When it is determined in step 606 that “z and z ′ match” or when the processing of step 607 is completed, the control is returned to step 602 (if the base value of i is 1, this control is performed). At this point, the number of loops is i).

If it is determined in step 602 that "the i-th adjacent relationship of G2 is A", the process is terminated.

[0117]

DESCRIPTION OF THE PREFERRED EMBODIMENTS A specific embodiment of the network type data structure address assignment / access method of the present invention will be described below.

(1) First Embodiment FIGS. 8 (a) and 8 (b) show data of a network type data structure showing a family tree using a conventional technique (a method based on a list structure) and the present invention (using a pair function). FIG. 7 is a diagram showing a specific example of coding described in (method) (example of description in C language).

The example of this figure is intended to show the effect of the present invention that not only the amount of data can be optimized, but also the amount of description can be suppressed and readability can be improved.

Here, the pair function is expressed not as (P, Q, R) but as (fro, to, link).
That is, the following equation (11) holds.

(Equation 13)

In the family tree described in FIG. 8, it is necessary to express each individual as being equal and to express a structure called parent-child relationship. This family tree must meet the following two requirements: First requirement: From the viewpoint of an individual, there are always two (born) parents and zero or more children. Second requirement: There are no children among siblings.

On the contrary, these requirements can be used as knowledge on the network configuration. FIG. 8 shows a source describing the structure of this family tree and a program for searching for an arbitrary cousin of a certain person b based on the family tree based on the list structure method and the present invention method. It is a coding example shown to (a) and (b).

In the conventional system (FIG. 8A), the data structure of the family tree is realized using two types of list structures. The list structure is divided into two types because the condition for the parent and the condition for the child are different from the above requirements.

On the other hand, the method of the present invention (FIG. 8)
In (b)), the condition for the parent and the condition for the child can be grasped in the same way. Therefore, the data structure can be unified into one.

In FIGS. 8A and 8B, the case where the number of children is 0 is not considered in order to clarify the processing flow.

When comparing FIG. 8A and FIG. 8B, in terms of the amount of description, data obtained by accessing five locations is obtained. As described above, since the substantial search step does not change, the amount of description does not basically change between the method using the list structure and the method using the pair function.

However, in FIG. 8A, the structure of the program merely follows the designated pointer one by one, and the content of the search processing is very difficult to understand.
In (b), the search method is semantic (directivity) because the access method is composed of two types of “link” and “to and fro”, and the structure of the program is more natural according to the meaning. It has become. Furthermore, since the parent and the child can search in the same way, there is no need to prepare a separate routine. That is, it can be seen that the source readability of FIG. 8B is high.

Note that the storage amounts are set to be the same here. In other words, in FIG. 8A, INFO1 is | V |, and INFO2 is | E |. This is because the above two conditions (the first requirement and the second requirement) are used as knowledge in the structure. This has been made possible by addressing the problem, and in general, a direct reference from INFO1 to itself (oya1, o
The list structure by ya2) is eliminated, and the reference to INFO2 is unified. Therefore, the reference is managed redundantly, and as a result, the storage amount is only | V | +2 | E |. In the method shown in FIG. 8A, the search is not arbitrary, and if all cousins are searched, the access may be made using data names, which may lead to a complicated program structure. Incidentally, in FIG. 8B, MAXSIZ
Although E is defined, it is merely to make the loop processing easier to understand, and there is no meaning in limiting the total amount of the set V and the set E.

(2) Second Embodiment FIG. 9 shows a part of the data processing routine 20 as a C routine.
FIG. 4 is a diagram showing an example described using a language (such a routine should be treated as a built-in routine due to its characteristics, but is described here because it is not built into an existing language).

This routine describes a square root integer part calculation routine and a batch combination processing routine using a pair function (see FIG. 5).

Note that, again, the pair function is (fro, t
o, link).

(3) Third Embodiment FIGS. 10 and 11 illustrate an embodiment of a network type data structure address assignment / access method according to the present invention for processing data of a network type data structure indicating job scheduling. FIG.

FIG. 10 is a diagram showing an example of the storage area 10 configured based on the equations (8) and (9) with A = 0. Here, as in FIG. 1B, the base value of the relative address is 1.

Consider job schedule management (data indicating scheduling) as an example of data.
When a plurality of applications are executed continuously or in parallel by specifying a start condition on one machine, the target application and the type of the start condition (time, termination of another application, etc.) must be centrally managed. .

At this time, if the application is represented by a point, the start time is represented by the position of the point, and the application located on the start point side of → between applications (between the points) is terminated, the job schedule The description (job flow) is data having a network type data structure as shown in FIG.

Here, the registered job (Job)
Are sequentially numbered 1, 2,..., 5, and job names are assigned in order from the base value number of the array. If we interpret this array as real data and interpret it as an adjacency relationship as seen from →,
The job flow illustrated in FIG. 11 includes seven sides (omitting the virtual side defined with respect to Expression (7)) and two starting points.
11 are shown as “virtual edge from start” or “virtual edge to end” in FIG. 11. Although they are illustrated clearly on the schedule, originally, start, end (Where N is an integer, and JobN is the Nth virtual point).

In FIG. 11, there are five jobs, and there is no serial connection. The configuration of the storage area 10 shown in FIG. 10 shows that such a data structure can be expressed simply and compactly according to the method of the present invention.

According to these schedules, each Job
In order to run (job), such information must be managed as data, but since this information is not serial, it must be represented as a network-type data structure. Strictly speaking, for example, J
In order for ob3 to be activated, Job1 and Job2 may be “whether (and) finished” or “either (or)
The meaning of the adjacency relationship such as "Is it finished?" Must be strictly defined, but in any case, it can be recognized that there are a plurality of parent processes.

(4) Although not illustrated as an embodiment, a more general application of the present invention is Windows.
It has a data structure in which a plurality of parent data exist, such as Help and Japanese FEP. When trying to represent information in the real world as unified data, multiple parents (reference sources of adjacent relationships)
There are many cases in which a data structure must be used. From this point of view, it can be said that the application range of the present invention is wide.

[0140]

As described above, according to the network type data structure address assignment / access method of the present invention, the following effects are produced.

The first effect is that a general-purpose access method to a network-type data structure can be realized and used without using a complicated list structure or the like for expressing the network-type data structure.

The reason why such an effect occurs is that a pair function is modeled as a method for obtaining a relative address of a storage area.

A second effect is that when a network-type data structure is realized by using the method of the present invention, the data structure can be used with only minimum information representing the data structure. . Specifically, the storage area is the sum of the number of actual data and the number of adjacency relations between data, that is, approximately | V | + | E | (since the data type is generally different from the actual data and the adjacency relation, , This formula is not exact) can be realized only by the storage capacity for storing the data (the storage area is not wasted).

The reason why such an effect occurs is that, by using the method of the present invention, a network-type data structure is defined only by a storage area of real data representing points of a graph (network) and adjacent relations representing edges. Because you can. It should be noted that a network cannot be expressed (configured) with an information amount smaller than this.

The third effect is that bidirectional information can be obtained only with unidirectional network structure information.

The reason why such an effect occurs is that the function P and the function Q constituting the pair function (P, Q, R) are dual, and the information on the start point and the end point can be simultaneously obtained from the information on one directed side. Because it can be obtained, it can be considered that a directed edge in the opposite direction exists in effect.

The fourth effect is that the readability increases with the same amount of description as the list structure.

The reason why such an effect occurs is that the amount of description for searching the same node is equal to the amount of description in the method using the list structure, and the search is performed in consideration of the directionality for simple pointer access in the list structure. And the algorithm becomes easier to understand.

[Brief description of the drawings]

FIG. 1A is a block diagram illustrating a configuration of an embodiment of a network type data structure address assignment / access method according to the present invention, and FIG. 1B is a diagram illustrating a configuration of a storage area in FIG. is there.

FIG. 2 is a diagram showing a specific example of a pair function (P, Q, R).

FIG. 3 is a flowchart showing an all-item search process by an access unit in FIG. 1;

FIG. 4 is a flowchart showing a partial search process by an access unit in FIG. 1;

FIG. 5 is a flowchart showing a batch combining process by an address allocating unit in FIG. 1;

FIG. 6 is a flowchart showing batch deletion processing by an address assignment unit in FIG. 1;

FIG. 7A is a diagram showing an example of a network-type data structure, and FIG. 7B is a diagram showing an example of a search for the network-type data structure of FIG.

FIG. 8 is a diagram for explaining an embodiment of the present invention; a coding example of a network-type data structure using a pair function (an example of description in C language) and a coding example of a list structure (description in C language); It is a figure for explaining in comparison with an example).

FIG. 9 is a diagram for explaining the embodiment of the present invention, and shows an example in which a part of a data processing routine using a pair function is described in C language.

FIG. 10 is a diagram for explaining an embodiment of the present invention;
FIG. 2 is a diagram illustrating an example of the contents of a storage area illustrated in FIG. 1A when data having a network-type data structure is information indicating job scheduling.

FIG. 11 is a diagram for explaining an embodiment of the present invention;
FIG. 11 is a diagram illustrating a job flow actually desired to be expressed as a network-type data structure of data in the storage area illustrated in FIG. 10.

[Explanation of symbols]

 Reference Signs List 10 storage area 11 actual data array 12 adjacency array 20 data processing routine 21 address allocation means 22 access means 30 paired function routine

──────────────────────────────────────────────────続 き Continuation of front page (58) Surveyed field (Int.Cl. ⁷ , DB name) G06F 12 / 02,17 / 30 JICST file (JOIS)

Claims (3)

(57) [Claims] In a network type data structure address assignment / access method for realizing address assignment and access to data of a network type data structure in a storage area, a network type data structure is defined by an actual data array and an adjacent relationship array. Said storage area for storing data; and z is used as directed edge information for address assignment of a network-type data structure.
= R (x, y), x = P (z), and y = Q (z), a pair function (P, Q,
A pair function routine shown a R), using a pair function of said pair function routine, "the storage area
In the actual data array in
X is the address of the "element storing the relevant data"
In the actual data array, the "end of the directed side representing the
The address of the "element storing the data corresponding to the point" to y
, And any element in the adjacency array has z =
R (x, y) in the algorithm that stores "a, an address allocation means for allocating the address of the network-type data structure in the storage area, by using a pair function of said pair function routine," given next
Stored in the adjacent relationship array in the storage area indicating the contact relationship.
X = P (z) and y = Q (z) from z
Calculate, if these x and y exist, z is the inverse function P ^-1
(X) and one of the solutions of the inverse function Q ^-1 (y)
Access means for accessing data of a network-type data structure in the storage area using an algorithm of "do" . 2. The method according to claim 1, wherein the terminal symbol of the adjacent relation array in the storage area is realized by “a value that cannot be taken as the value of the function R in the pair function (P, Q, R)”.
Network type data structure address assignment and access method as described. 3. The method according to claim 1, wherein a Cantor pair function is adopted as a pair function in the pair function routine.
3. A network type data structure address assignment / access method according to claim 2.