无限级分类，左右值算法

最新推荐文章于 2021-03-02 10:47:34 发布
最新推荐文章于 2021-03-02 10:47:34 发布
阅读量651 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_16490557/article/details/36173903 
<?php

class IndexAction extends Action{
    
    private $model;
    
    public function __construct()
    {
        parent::__construct();
        $this->model= M("catagory");
        //var_dump($this->model);
    }
    // 首页
    public function index(){
        $this->delete();

        $arry = array();
        $arry['text'] = 'root';$pid = $this->insert($arry,0);

        $arry['text'] = "1";$id1 = $this->insert($arry,$pid);
        $arry['text'] = "2";$id2 = $this->insert($arry,$pid);
        $arry['text'] = "3";$id3 = $this->insert($arry,$pid);
        $arry['text'] = "4";$id4 = $this->insert($arry,$pid);

        $arry['text'] = "2-1";$id21 = $this->insert($arry,$id2);
        $arry['text'] = "2-2";$id22 = $this->insert($arry,$id2);

        $arry['text'] = "4-1";$id41 = $this->insert($arry,$id4);
        $arry['text'] = "4-2";$id42 = $this->insert($arry,$id4);

        $arry['text'] = "5";$id5 = $this->insert($arry,$pid);

        $arry['text'] = "3-1";$id31 = $this->insert($arry,$id3);
        $arry['text'] = "3-2";$id32 = $this->insert($arry,$id3);
        $arry['text'] = "3-3";$id33 = $this->insert($arry,$id3);

        $arry['text'] = "3-2-1";$id321 = $this->insert($arry,$id32);
        $arry['text'] = "3-2-2";$id322 = $this->insert($arry,$id32);
        $arry['text'] = "3-2-3";$id323 = $this->insert($arry,$id32);

        var_dump($this->get($id3)); //获取节点数据
        var_dump($this->parents($id322)); //获取直属父节点，不包含自身
        var_dump($this->parents($id322,true)); //获取直属父节点，包含自身
        var_dump($this->parents($id322,false,true));//获取全部父节点，不包含自身
        var_dump($this->parents($id322,true,true)); //获取全部父节点，包含自身
        var_dump($this->count($id3)); //获取直属子节点个数
        var_dump($this->childs($id3)); //获取直属子节点，不包含自身
        var_dump($this->childs($id3,true)); //获取直属子节点，包含自身
        var_dump($this->childs($id3,false,true)); //获取全部子节点，不包含自身
        var_dump($this->childs($id3,true,true)); //获取全部子节点，包含自身

        echo "exchange";
        $this->exchange($id321,$id322); //同节点替换
        $this->exchange($id323,$id31); //不同节点替换
        var_dump($this->childs($id3,false,true)); //检查

    }

    //返回id号，如果为0则表示失败
    public function insert($data,$pid) {
        if($pid == 0)
        {//根节点
            $v = $this->model->query("select count(*) as result from __TABLE__");
            if (is_array($v) && $v[0]['result'] == 0) {
                $data['left'] = 0;
                $data['right'] = 1;
                $data['level'] = 0;
                return $this->model->add($data);
            }
        }else if(is_array($pdata = $this->get($pid))){
            //非根节点，且存在
            $left=$pdata[0]['left']; 
            $right=$pdata[0]['right']; 
            $this->model->query("UPDATE __TABLE__ SET `left`=`left`+2 WHERE `left` >$right"); 
            $this->model->query("UPDATE __TABLE__ SET `right`=`right`+2 WHERE `right`>=$right");
            $data['left'] = $right;
            $data['right'] = $right+1;
            $data['level'] = $pdata[0]['level']+1;
            return $this->model->add($data);
        }
        return 0;
    }
    public function delete($id = 0){
        //truncate table 你的表名
        if($id == 0 || $id == 1 )
        {
            $this->model->query("truncate table __TABLE__ ");
        }else{
            if(is_array($pdata = $this->get($id))){
                $level = $pdata[0]['level'];
                if($level ==0){//仍然是根节点
                    $this->model->query("truncate table __TABLE__ ");
                    return;
                }
                //非根节点，且存在
                $left = $pdata[0]['left'];
                $right = $pdata[0]['right'];
                $this->model->where("`left`>={$left} and `right`<=$right")->delete();
                //更新左右值
                $value=$right-$left+1; 
                $this->model->query("UPDATE __TABLE__ SET `left` =`left` - $value WHERE `left`> $left"); 
                $this->model->query("UPDATE __TABLE__ SET `right`=`right`- $value WHERE `right`>$right"); 
            }
        }
    }
    public function move($id,$parentId){
        if($id>1 && is_array($src = $this->get($id)) && is_array($pdata = $this->get($parentId)))
        {//不是根节点，两个节点都存在
            $left = $src[0]['left']; 
            $right = $src[0]['right']; 
            $level = $src[0]['level'];
            $pleft = $pdata[0]['left']; 
            $pright = $pdata[0]['right']; 
            $plevel = $pdata[0]['level'];
            
            $value_between = $right-$left + 1;
            $level_src = $plevel - $level +1;
            if($pright>$right){
                $this->model->query("UPDATE __TABLE__ SET `left` =`left` - $value_between WHERE `left`> $right and `right`<=$pright");
                $this->model->query("UPDATE __TABLE__ SET `right` =`right` - $value_between WHERE `right`> $right and `right`<$pright");
                $value_src = $pright-$right-1;
                $this->model->query("UPDATE __TABLE__ SET `right` = `right` + $value_src,`left`=`left`+$value_src,`level`=`level`+$level_src WHERE `right`<= $right and `left`>=$left");
            }else{
                $this->model->query("UPDATE __TABLE__ SET `left` =`left` + $value_between WHERE `left`> $pright and `left`<=$left");
                $this->model->query("UPDATE __TABLE__ SET `right` =`right` + $value_between WHERE `right`>= $pright and `right`<$left");
                $value_src = $left-$pright;
                $this->model->query("UPDATE __TABLE__ SET `right` = `right` - $value_src,`left`=`left`-$value_src,`level`=`level`+$level_src WHERE `right`<= $right and `left`>=$left");
            }
        }
    }
    //如果有返回数组，否则返回false
    public function get($id){
        if($id==0)
            $id = 1;
        return $this->model->query("select * from __TABLE__ where id = {$id}");
    }
    //不存在则返回0
    public function count($id) {
        if(is_array($pdata = $this->get($id))){
            $v = $this->model->query("select count(*) as result from __TABLE__ where `left`>{$pdata[0]['left']} and `right`<{$pdata[0]['right']} and level = {$pdata[0]['level']}+1");
            if (is_array($v)) {
                return $v[0]['result'];
            }
        }
        return 0;
    }
    //获取直属子节点数组 $self：是否包含自身，$allChilds：是否包含所有子节点
    public function childs($id,$self=false,$allChilds=false) {
        if($id == 0){
            $left = 0; 
            $right = 0; 
            $level = 0;
        }else if(is_array($pdata = $this->get($id))){
            $left = $pdata[0]['left'];
            $right = $pdata[0]['right'];
            $level = $pdata[0]['level'];
        }else{
            return 0;
        }
        $self_filter = $self ? " `left`>={$left} and `right`<={$right} " : " `left`>{$left} and `right`<{$right} ";
        if($self){
            $level_filter = $allChilds ? " `level` >={$level} " : " `level` <={$level}+1 ";
        }else
            $level_filter = $allChilds ? " `level` >={$level} " :" `level` ={$level}+1 ";
        return $this->model->query("select * from __TABLE__ where {$self_filter} and {$level_filter} order by `level` asc,`left` asc");
    }
    //获取父节点
    public function parents($id,$self=false,$allParents=false) {
        if($id == 0){
            $left = 0;
            $right = 0;
            $level = 0;
        }else if(is_array($pdata = $this->get($id))){
            $left = $pdata[0]['left']; 
            $right = $pdata[0]['right']; 
            $level = $pdata[0]['level'];
        }else{
            return 0;
        }
        if($self){
            if($allParents)
                $level_filter = "level <=$level";
            else
                $level_filter = "level >=$level-1";
        }else{
            if($allParents)
                $level_filter = "level <$level";
            else
                $level_filter = "level =$level-1";
        }
        return $this->model->query("select * from __TABLE__ where `left`<={$left} and {$level_filter} and `right`>={$right} order by `level` asc,`left` asc");
    }
    //交换
    public function exchange($id1,$id2){
        if(is_array($data1 = $this->get($id1)) && is_array($data2 = $this->get($id2))){
            // left right level
            $udata1 = array();
            $udata1['left'] = $data1[0]['left'];
            $udata1['right'] = $data1[0]['right'];
            $udata1['level'] = $data1[0]['level'];
            
            $udata2 = array();
            $udata2['left'] = $data2[0]['left'];
            $udata2['right'] = $data2[0]['right'];
            $udata2['level'] = $data2[0]['level'];
            $this->model->where("`id`={$data2[0]['id']}")->save($udata1);
            $this->model->where("`id`={$data1[0]['id']}")->save($udata2);
        }
    }
    //返回树结构,暂时未完
    public function tree($id){
        if(is_array($lists = $this->lists($id))){
            $result = array();
            
            $level = -1; //当前的level
            $iter = null; //父item
            $piter = &$result;//父父item
            $index = 0; //父的index

            for($i=0;$i<count($lists);$i++)
            {
                $list_level = $lists[$i]['level'];
                $list_right = $lists[$i]['right'];
                if($list_level > $level){//level增加
                    if($level == -1)
                    {//根，添加
                        $item = array();
                        $item['data'] = $lists[$i];
                        $item['items'] = array();
                        $piter['items'][] = $item;
                        //$piter = &$piter['items'][0];
                        $level = $list_level; //level赋值
                        continue;
                    }else if($level != 0){
                        $piter = &$piter['items'][0];
                    }
                    $index = 0; //父的index重置
                    $level = $list_level; //level赋值
                }
                $iter = &$piter['items'][$index];
                $p_right = $iter['data']['right'];
                if($list_right > $p_right)
                {
                    $iter = &$piter['items'][++$index];
                }
                
                $item = array();
                $item['data'] =$lists[$i];
                $item['items'] = array();
                $iter['items'][] = $item;
            }
            //$result['text']=
            return $result;
        }
    }
}
?>


左右值算法
　　不气馁的博客
04-24 863
左右值无限级分类算法 为什么要使用左右值来表示无限级分类？ 一般我们会使用parent标识来表示节点之间的上下级关系，好处是结构清晰，修改起来非常方便，缺点是查询很麻烦，可能需要使用到递归查询，递归的使用将会使性能大幅度降低尤其是递归层级多的时候，有些查找，比如统计当前节点的所有子节点个数（例如：钉钉的组织架构无限级），这就必须要递归到最后一级，所以在类似于这种需要递归到最后一级才能返回结果的场景，我们就可以补充左右值来提升性能。 左右值如何表示？ Node属性和方法： public class Node{
mysql 左右值算法详解_基于左右值的无限级分类算法(1) – 插入节点
weixin_39755218的博客
02-27 544
原创文章，未经允许，请勿转载！关系型数据库一般都是以平面方式来存储我们的数据，这就造成了我们在实现一些数据结构上的麻烦，比如说如何实现高效的无限级的网站分类，这里MySQL的《Managing Hierarchical Data in MySQL》给出了一个比较好的办法，基于一种左右值的算法，这也是我目前接触到的查询比较高效的算法了，另外Gijs Van Tulder在sitepoint也写过一篇...
采用左右值编码来存储无限分级树形结构的数据库表设计
我的地盘—我做主
12-19 280
采用左右值编码来存储无限分级树形结构的数据库表设计 作者:绯雨 日期:2008-03-28 字体大小: 小 中 大 作者: bobcy的专栏无限分级的编码方案——左右值。原文的程序代码是用php写的，但是通过仔细阅读其数据库表设计说明及相关的sql语句，我彻底弄懂了这种巧妙的设计思路，并在这种设计中新增了删除节点，同层平移的需求（原文只提供了列表及插入子节点的sql语句）。　　下面我力图用...
mysql 左右值算法详解_Mysql之运用预排序树算法
weixin_29621655的博客
02-01 319
首先创建表结构：SET NAMES utf8mb4;SET FOREIGN_KEY_CHECKS = 0;-- ------------------------------ Table structure for test-- ----------------------------DROP TABLE IF EXISTS `test`;CREATE TABLE `test` (`id` int(...
无限级分类/多级分类【左右值方式实现】
08-12
无限级分类/多级分类【左右值方式实现】，压缩包中mysql.db.sql是MySQL建表及初始化SQL，index.php文件前几个行是数据库连接的参数。
掌握PHP实现无限级分类的MySQL数据库结构
创建无限级分类时，需要一个算法来递归地为每个节点分配左右值，并保证这些值不会相互冲突。 在本例中，提供的MySQL数据库脚本文件为mysql.db.sql，这个文件包含了创建所需表格和插入初始数据的SQL语句。通常这类...
PHP实现无限级分类的2种方法——父值与左右值2
wjtlht928的专栏
07-17 3666
一、绪论 产品分类，多级的树状结构的论坛，邮件列表等许多地方我们都会遇到这样的问题：如何存储多级结构的数据？在PHP的应用中，提供后台数据存储的通常是关系型数据库，它能够保存大量的数据，提供高效的数据检索和更新服务。然而关系型数据的基本形式是纵横交错的表，是一个平面的结构，如果要将多级树状结构存储在关系型数据库里就需要进行合理的翻译工作。 层级结构的数据保存在平面的数据库中基本上有两种常用设计
实现无限级分类的MPTT存储过程详解与应用
预排序遍历树算法（MPTT）是一种用于存储和处理树形结构数据的技术，尤其是在数据库中实现无限级分类系统时。该算法通过在每个节点存储左右值（left, right）来维护树的结构，以保证在遍历树时保持一个预排序的顺序...
MySQL 所推荐的左右值法（毗邻目录法、预排序历遍法）
云淡风轻、仅此一抹
01-18 9100
毗邻目录法： 这种方法说白了就是子类，依赖父类，父类依赖爷爷类，爷爷类可以有多个儿子类，跟父类平级的类。一层一层的。 预排序历遍法： 这种算法比较高端，使用的是mysql官方推荐的左右算法。 使用场合：多级目录，多层关联的情况。 而我的使用场合就是典型的省市县3级关联。下面先来简单了解下它们的原理。 关于省市县的文章以后有空再放出。 以下3篇文章分别摘自互联网。都是3
MySQL 左右值无限分类 预排序遍历树算法
weixin_34026276的博客
10-04 667
2019独角兽企业重金招聘Python工程师标准>>> ...
解析左右值无限分类的实现算法
10-27
本篇文章是对php左右值无限分类的实现算法进行了详细的分析介绍，需要的朋友参考下
左右值无限分类实现算法
hegz
03-30 200
文章来源：http://bbs.phpchina.com/viewthread.php?tid=92550&amp;extra=page%3D1%26amp%3Bfilter%3Ddigest （其 实也是转的 ） 一、引言 产品分类，多级的树状结构的论坛 ，邮件列表等许多地方我们都会遇到这样的问题 ：如何存储多级结构的数据 ？在PHP 的应用中，提供后台数据存储的通...
左右值无限级分类算法
好好学习，好好工作
07-22 1996
<br />为例来实现：<br /><br />如图所示我们将一个树节点的左右各编上号码，就可以看出一些规律，山西的左右值为(8,17)，那么所有左值大于8，右值小于17的节点都是属于山西的子节点。稷山先的左右值为(14,15)，那么他的所有父节点就是左值小于14，右值大于15的节点，怎么样，用这个方法实现的无限级分类性能绝对是顶呱呱的。一次查询就可以查出属于某个节点的数据以及他子节点的数据。这个算是我见过性能最高的无限级分类算法。其他算法跟这个对比基本没有任何优势。<br />我们先建立一个数据表，结构如
mysql 左右值算法详解_无限分类左右值算法的常规操作逻辑
weixin_32951341的博客
02-01 629
一、计算A节点的子节点数。$num = ($AR - $AL -1)/2;二、查找A节点的所有子节点。select * from tree where L > $AL and R < $AR order by L asc;三、查找A节点的所有父节点。select * from tree where L < $AL and R > $AR order by L desc;四、...
左右值无限级分类算法（预排序遍历树算法）
猛犸象
03-02 2792
1、为什么要使用左右值来表示无限极分类 一般的，我们会使用parent标志来表示节点之间的上下级关系，好处是结构清晰，修改起来很方便，缺点是查找起来稍微麻烦一点，可能需要使用递归查询，递归的使用将会使性能大幅降低尤其是递归层级多的时候。有些查找，比如统计当前节点的所有子节点个数，这就必须要递归到最后一级，所以在类似于这种需要递归到最后一级才能返回结果的场景，我们可以补充以左右值来提升性能。 以下是常规的数据结构，数据随机生成： /** * 生成测试数据 * php think data --action
基于左右值的无限分类算法
weixin_34112208的博客
09-09 185
2019独角兽企业重金招聘Python工程师标准>>> ...
mysql左右值无限分类原理及实现
gst6062825的专栏
05-19 1630
无限分类是我们开发中非常常见的应用，我们最常见最简单的方法就是在MySql里id ,name,f_id。 优点是简单，结构简单。 缺点是效率不高，因为每一次递归都要查询数据库，几百条数据库时就不是很快了！ 存储树是一种常见的问题，多种解决方案。主要有两种方法：邻接表的模型，并修改树前序遍历算法。 我们将探讨这两种方法的节能等级的数据。我会使用树从一个虚构的网上食品商店作为一个例子。这食品商店组
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值