Post a few PHP infinite classification implementation ideas~_PHP tutorial

1. Anyone who builds a website will generally encounter the problem of processing classifications. I will post a few examples of processing unlimited classifications
The structure of the database is very simple:
id, fatcher_id, name, .. ....
This design is short and concise, and fully meets 3NF. It can meet most of the requirements. OK, let us take a look at the program implementation under this database structure.

1. Recursive query Database
The most terrible approach ~ and the best implementation
Category 1
Category 1.1
Category 1.1.1
Category 1.2
Category 2
Category 2.1
Category 3
Category 3.1
Category 3.2
...
In order to generate such a directory structure, the program recursively queries the database once, wherever you involve classification (turning pages, Query....), the database will tragically operate the hard disk....Amen~so~let’s jump...
2. Query the database once, and the recursive array will generate the above directory structure
Post a general idea
function SelectList(&$Data, $RootID = 0')
{
for($i = 0; $i < count($Data); $i++) <​​​! Output;
}
This kind of intensity of recursion is enough for ordinary websites~ However, if you encounter BT points, there are several K or even W categories, and the recursion may take more than 100 milliseconds. Considering concurrency In this case... Haha~ Let’s jump again

3. Query the database once and generate the directory structure non-recursively

In this step, the trick of the program is here~ only traverse the results once You can generate the directory structure like the one above. It is very convenient to format it into a web page display style. The following is written by someone else. I have tried it and it is completely feasible.
function GetArray($RootID = 0)
{
$Data = array();

$Data = $tblObj->MapResult($tblObj->Select()); $Output = Array();
$i = 0;
$len = Count($Data);
if($RootID)
{
while($Data[$i]['UID'] != $RootID && $i < $len) $i++;
}
$UpID = $RootID; //The category parent ID pointed to by the previous node
for($cnt = Count($Data); $i < $cnt;) //Traverse the entire classification array
{
$j = 0; //Initialize the sub-category data count under this classification
if ($UpID == $RootID) / /In the first loop, save all first-level classifications to the $Output array
                                                                                                                                                                                                                                                       ) // Determine whether the previous node is a sibling node
{
{
$Output[$j] = $Data[$i]; //Save the node to the Output array
$tmp[$Data [$i]['ID']] = &$Output[$j]; //And save the position of the node ID in Output.
                                                           
}
else
{
while($Data[$i]['UID'] == $UpID && $i < $len)
                                                                                         UpID ])
                                                                     = &$tmp[$UpID]['Child'][$j]; //Save the position of the node ID in Output
                                                                                                                                  🎜>                                                                                                                                   

The program looks so tiring~ The efficiency of this code is more than ten times faster than the previous one, and the strength system is strong enough...
However...90% of websites use it Such code is a waste~ The website classifications I have encountered are generally below level 4, so, can it be optimized further?... Let's jump again...
4. Start with the database~
Slightly change the structure of the database and add a redundant field for layer. This was thought up by a db desing expert. I just posted it.
id name father_id layer
1 Total category 0 Category 1 1 010000
3 Category 1.1 2 010100
4 Category 1.2 2 0102 00
5 Category 2 1 020000
6 Category 2.1 5 020100
7 Category 3 1 030000
8 Category 3.1 7 030100
9 Category 3.2 7 030200
10 Category 1.1.1 3 010101

Now search by the size of the layer Take a look: SELECT * FROM Type_table_2 ORDER BY type_layer

List records The set is as follows:

id name father_id layer
1 Total Category 000000
2 Category 1 1 010000
3 Category 1.1 2 010100
10 Category 1.1.1 3 010101
4 Category 1.2 2 010200
5 Category 2 1 020000
6 Category 2.1 5                                                                                                                                                                                             3.2 7 030200

See? Even the directory structure is generated in one query~ This makes the program much easier. It just requires more work to maintain the layer field. In this routine, the layer field can handle 99 categories at each level. If there is BT For the application, just make it bigger. Haha, analyze your needs first

OK~OVER~SHANGREN~

http://www.bkjia.com/PHPjc/317650.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/317650.htmlTechArticle1. Those who build websites will generally encounter the problem of processing categories. I will occasionally post a few examples of processing unlimited categories. The structure of the database is very simple: id, fatcher_id, name,... This design is short and concise...