Example of Tree Structure Data Access implemented by php

This article mainly introduces the Tree Structure Data Access class implemented by php. The example demonstrates how to access data with a tree structure, it has some reference value for learning PHP-based data structures.

This article mainly introduces the Tree Structure Data Access class implemented by php. The example demonstrates how to access data with a tree structure, it has some reference value for learning PHP-based data structures.

This example describes the Tree Structure Data Access class implemented by php. Share it with you for your reference.

The specific implementation code is as follows:

The Code is as follows:

<? Php
/**
* Tanphp framework
*
*
* @ Category Tanphp
* @ Package Data_structure
* @ Version $ Id: Tree. php 25024 22:22:22 tanbo $
*/

/**
* Tree Structure Data Access class
*
* Quick access to tree data
*
* @ Param array $ arr The parameter must be a standard two-dimensional array that contains the index field (id) and the field (path) representing the tree structure, as shown in example.
*
* @ Example
* $arr = array(
* array( 'id' => 1, 'name' => 'php', 'path' => '1' ),
* array( 'id' => 3, 'name' => 'php1', 'path' => '1-3' ),
* array( 'id' => 2, 'name' => 'mysql', 'path' => '2' ),
* array( 'id' => 6, 'name' => 'mysql1', 'path' => '2-6' ),
* array( 'id' => 7, 'name' => 'mysql2', 'path' => '2-7' ),
* array( 'id' => 5, 'name' => 'php11', 'path' => '1-3-5' ),
* array( 'id' => 4, 'name' => 'php2', 'path' => '1-4' ),
* );
* $cate = new Tree($arr);
*
* $data = $cate->getChild(2);
*
* print_r($data->toArray());
*
*
*/
Class Tree
{
Public $ _ info; // node Information
Public $ _ child = array (); // subnode
Private $ _ parent; // parent node
Private $ _ data; // temporary data of the current operation
Private static $ _ indexs = array (); // index of all nodes
Private static $ _ index_key = 'id'; // index key
Private static $ _ tree_key = 'path'; // tree expression key
Private static $ _ tree_delimiter = '-'; // attribute structure expression delimiter

/**
* Constructor
*
* @ Param array $ arr
* @ Param boole $ force_sort if true, $ arr is forcibly ordered.
* @ Return void
*/
Public function _ construct (array $ arr = array (), $ force_sort = true)
{
If ($ force_sort === true ){
$ Arr = $ this-> _ array_sort ($ arr, self: $ _ tree_key );
}
If (! Emptyempty ($ arr )){
$ This-> _ init ($ arr );
}
}

/**
* Initial storage of tree data
*
* @ Param array $ arr
* @ Return void
*/
Private function _ init (array $ arr)
{
Foreach ($ arr as $ item ){
$ Path = $ item [self: $ _ tree_key];
$ Paths = explode (self: $ _ tree_delimiter, $ path );
$ Count_paths = count ($ paths );
$ Parent_id = isset ($ paths [$ count_paths-2])? $ Paths [$ count_paths-2]: NULL;

If ($ count_paths> 1 // if there is a parent
& Array_key_exists ($ parent_id, self: $ _ indexs) // The parent database has been stored in the index.
& Self: $ _ indexs [$ parent_id] instanceof Tree // The parent class is a Tree object.
){
Self: $ _ indexs [$ parent_id]-> addChild ($ item );
} Elseif ($ count_paths = 1 ){
$ This-> addChild ($ item );
} Else {
Throw new Exception ("path data error". var_export ($ item, true ));
}
}

// Print_r (self: $ _ indexs );
}

/**
* Add a subnode
*
* @ Param array $ item
* @ Return void
*/
Public function addChild (array $ item, $ parent = NULL)
{
$ Child = new Tree ();
$ Child-> _ info = $ item;
$ Child-> _ parent = $ parent = NULL? $ This: $ parent;
$ Child-> _ parent-> _ child [] = $ child;

$ This-> _ addIndex ($ item, $ child-> _ getSelf ());
}

/**
* Add a node to the index
*
* @ Param array $ item
* @ Param mix $ value
* @ Return void
*/
Private function _ addIndex (array $ item, $ value)
{
If (array_key_exists (self: $ _ index_key, $ item) & is_int ($ item [self: $ _ index_key]) {
Self: $ _ indexs [$ item [self: $ _ index_key] = $ value;
} Else {
Throw new Exception ("the id field does not exist or is not a string ");
}
}

/**
* Obtain your own references.
*
* @ Return Tree object quote
*/
Private function _ getSelf ()
{
Return $ this;
}

/**
* Obtain the subnode of the node with the specified id
*
* @ Param int $ id
* @ Return Tree object
*/
Public function getChild ($ id)
{
$ Data = self: $ _ indexs [$ id]-> _ child;
$ This-> _ data = $ data;
Return $ this;
}

/**
* Obtain the parent node of the node with the specified id
*
* @ Param int $ id
* @ Return Tree object
*/
Public function getParent ($ id)
{
$ Data = self ::$ _ indexs [$ id]-> _ parent;
$ This-> _ data = $ data;
Return $ this;
}

/**
* Get the same-level node of the node with the specified id
*
* @ Param int $ id
* @ Return Tree object
*/
Public function getBrother ($ id)
{
$ Data = self ::$ _ indexs [$ id]-> _ parent-> _ child;
$ This-> _ data = $ data;
Return $ this;
}

/**
* Convert a Tree object to an array
*
* @ Param object $ object
* @ Return array
*/
Public function toArray ($ obj = NULL)
{
$ Obj = ($ obj = NULL )? $ This-> _ data: $ obj;
$ Arr = array ();
$ _ Arr = is_object ($ obj )? $ This-> _ getBaseInfo ($ obj): $ obj;

If (is_array ($ _ arr )){
Foreach ($ _ arr as $ key => $ val ){

$ Val = (is_array ($ val) | is_object ($ val ))? $ This-> toArray ($ val): $ val;
$ Arr [$ key] = $ val;
}
} Else {
Throw new Exception ("_ arr is not an array ");
}

Return $ arr;
}

/**
* Filter fields such as _ parent to avoid infinite loops.
*
* @ Param object $ obj
* @ Return void
*/
Private function _ getBaseInfo ($ obj)
{
$ Vars = get_object_vars ($ obj );
$ BaseInfo ['_ info'] = $ vars [' _ info'];
$ BaseInfo ['_ child'] = $ vars ['_ child'];
Return $ baseInfo;
}

/**
* Two-dimensional array sorting
*
* Sort two-dimensional arrays in ascending or descending order based on the specified key name
*
* @ Param array $ arr two-dimensional array
* @ Param string $ keys
* @ Param string $ type must be asc or desc
* @ Throws an exception when the parameter is invalid.
* @ Return returns the sorted array.
*/
Private function _ array_sort (array $ arr, $ keys, $ type = 'asc '){
If (! Is_string ($ keys )){
Throw new Exception ("invalid parameter keys: the type of the parameter keys must be a string ");
}

$ Keysvalue = $ new_array = array ();
Foreach ($ arr as $ k =>$ v ){
If (! Is_array ($ v) |! Isset ($ v [$ keys]) {
Throw new Exception ("the arr parameter is not a two-dimensional array or the arr sub-element does not contain the key '{$ keys }'");
}
$ Keysvalue [$ k] = $ v [$ keys];
}

Switch ($ type ){
Case 'asc ':
Asort ($ keysvalue );
Break;
Case 'desc ':
Arsort ($ keysvalue );
Break;
Default:
Throw new Exception ("invalid parameter type: the value of the parameter type must be 'asc 'or 'desc '");
}

Reset ($ keysvalue );
Foreach ($ keysvalue as $ k => $ v ){
$ New_array [$ k] = $ arr [$ k];
}
Return $ new_array;
}
}
?>

I hope this article will help you with PHP programming.