Tree structure data access class instance implemented by PHP, tree instance

Tree structure data access class instance implemented by PHP, tree instance_PHP tutorial

WBOY

Release： 2016-07-13 10:12:45

Original

1063 people have browsed it

Instance of tree structure data access class implemented by PHP, tree instance

The example in this article describes the tree structure data access class implemented by PHP. Share it with everyone for your reference.

The specific implementation code is as follows:

Copy code The code is as follows:

/**
* Tanphp framework
*
*
* @category   Tanphp
* @package    Data_structure
* @version    $Id: Tree.php 25024 2012-11-26 22:22:22 tanbo $
*/

/**
* Tree structure data access class
*
* Used for fast access to tree structure data
*
* @param array $arr The parameter must be a standard two-dimensional array, including the index field (id) and the field representing the tree structure (path), as shown in example
*
* @example

 <br>
* $arr = array( <br>
* array( 'id' => 1, 'name' => 'php', 'path' => '1' ), <br>
* array( 'id' => 3, 'name' => 'php1', 'path' => '1-3' ), <br>
* array( 'id' => 2, 'name' => 'mysql', 'path' => '2' ), <br>
* array( 'id' => 6, 'name' => 'mysql1', 'path' => '2-6' ), <br>
* array( 'id' => 7, 'name' => 'mysql2', 'path' => '2-7' ), <br>
* array( 'id' => 5, 'name' => 'php11', 'path' => '1-3-5' ), <br>
* array( 'id' => 4, 'name' => 'php2', 'path' => '1-4' ), <br>
* ); <br>
* $cate = new Tree($arr); <br>
* <br>
* $data = $cate->getChild(2); <br>
* <br>
* print_r($data->toArray()); <br>
*

*
*/
class Tree
{
Public $_info; //Node information
Public $_child = array(); //Child node
private $_parent; //Parent node
private $_data; //Temporary data for the current operation
Private static $_indexs = array(); //Indices of all nodes
Private static $_index_key = 'id'; //Index key
Private static $_tree_key = 'path'; //Tree structure expression key
Private static $_tree_delimiter = '-'; //Attribute structure expression delimiter

/**
* Constructor
* *
* @param array $arr
* @param boole $force_sort If true, $arr will be forced to be sorted
* @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) {
                 $count_paths = count($paths);
$parent_id = isset($paths[$count_paths-2]) ? $paths[$count_paths-2] : NULL;
if ( $count_paths>1                                                                                                                                                                                                             && array_key_exists($parent_id, self::$_indexs)                                                                                   && self::$_indexs[$parent_id] instanceof Tree                          ) {
                                                            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 child node
* *
* @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 node to 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");
          }
}

/**
* Get a reference to yourself
* *
* @return Tree object quote
*/
Private function _getSelf()
{
          return $this;
}

/**
* * Get the child nodes 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;
    }

    /**
* Get 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 sibling nodes 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 Tree object into 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不是数组");
        }

        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
* *
* Arrange the two-dimensional array in ascending or descending order according to the specified key name
* *
* @param array $arr two-dimensional array
* @param string $keys
* @param string $type must be asc or desc
* @throws throws an exception when the parameter is illegal
* @return Returns the sorted array
*/
    private function _array_sort(array $arr, $keys, $type = 'asc') {
If (!is_string($keys)) {
                  throw new Exception("Illegal parameter keys: The type of parameter keys must be string");
          }

          $keysvalue = $new_array = array();
foreach ($arr as $k=>$v) {
If (!is_array($v) || !isset($v[$keys])) {
                      throw new Exception("The parameter arr is not a two-dimensional array or the key '{$keys}' does not exist in the arr sub-element");
               }
               $keysvalue[$k] = $v[$keys];
          }

          switch ($type) {
case 'asc':
asort($keysvalue);
break;
case 'desc':
                 arsort($keysvalue);
break;
                  default:
                         throw new Exception("Illegal parameter type: the value of 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 be helpful to everyone’s PHP programming design.