mysql无限极分类

最新推荐文章于 2022-04-08 22:23:51 发布
最新推荐文章于 2022-04-08 22:23:51 发布
阅读量971 收藏
点赞数
分类专栏： php
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanwangxia/article/details/116048146
版权

CREATE TABLE `tree` (
  `id` INT(10) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(255) NOT NULL,
  `lft` INT(10) NOT NULL DEFAULT '0' COMMENT '左节点',
  `rgt` INT(10) NOT NULL DEFAULT '0' COMMENT '右节点',
  `status` INT(1) NOT NULL DEFAULT '0' COMMENT '逻辑删除 1是 0否',
  PRIMARY KEY (`id`),
  KEY `lft` (`lft`),
  KEY `rgt` (`rgt`),
  KEY `status` (`status`)
) ENGINE=INNODB  DEFAULT CHARSET=utf8;

第一个节点
INSERT INTO tree VALUES (NULL, 'A', 0, 1, 0);
SELECT * FROM tree

$a_l = 0; $a_r = 1;
第二个节点（A的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 1;#lft > $a_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 1;#rgt >= $a_r
INSERT INTO tree VALUES (NULL, 'B', 1, 1+1, 0);#(NULL, 'B', $a_r, $a_r + 1, 0);

$a_l = 0; $a_r = 3;
第三个节点（A的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 3;#lft > $a_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 3;#rgt >= $a_r
INSERT INTO tree VALUES (NULL, 'C', 3, 3+1, 0);#(NULL, 'C', $a_r, $a_r + 1, 0);

$a_l = 0; $a_r = 5;
第四个节点（A的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 5;#lft > $a_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 5;#rgt >= $a_r
INSERT INTO tree VALUES (NULL, 'D', 5, 5+1, 0);#(NULL, 'D', $a_r, $a_r + 1, 0);

$b_l = 1; $b_r = 2;
第五个节点（B的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 2;#lft > $b_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 2;#rgt >= $b_r
INSERT INTO tree VALUES (NULL, 'E', 2, 2+1, 0);#(NULL, 'E', $b_r, $b_r + 1, 0);

$b_l = 1; $b_r = 4;
第六个节点（B的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 4;#lft > $b_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 4;#rgt >= $b_r
INSERT INTO tree VALUES (NULL, 'F', 4, 4+1, 0);#(NULL, 'F', $b_r, $b_r + 1, 0);

$e_l = 2; $e_r = 3;
第六个节点（E的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 3;#lft > $e_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 3;#rgt >= $e_r
INSERT INTO tree VALUES (NULL, 'G', 3, 3+1, 0);#(NULL, 'G', $e_r, $e_r + 1, 0);

$e_l = 2; $e_r = 5;
删除节点（E节点）
$v = 5 - 2 + 1 = 4;#$v = $e_r - $e_l + 1; 
DELETE FROM tree WHERE lft >= 2 AND rgt <= 5;#lft >= $e_l and rgt <= $e_r
UPDATE tree SET lft = lft - 4 WHERE lft > 2;#lft = lft - $v where lft > $e_l
UPDATE tree SET rgt = rgt - 4 WHERE rgt > 5;#rgt = rgt - $v WHERE rgt > $e_r

$b_l = 1; $b_r = 4;
删除节点（B节点）
$v = 4 - 1 + 1 = 4;#$v = $b_r - $b_l + 1; 
DELETE FROM tree WHERE lft >= 1 AND rgt <= 4;#lft >= $b_l and rgt <= $b_r
UPDATE tree SET lft = lft - 4 WHERE lft > 1;#lft = lft - $v where lft > $b_l
UPDATE tree SET rgt = rgt - 4 WHERE rgt > 4;#rgt = rgt - $v WHERE rgt > $b_r

总结：
一、根节点
lft=0,rgt=1
二、添加子节点:
找到父节点的右值$p_r，所有节点左值 > $p_r 的左值 + 2；所有节点右值 >= $p_r的右值 +2;插入新节点lft=$p_r,rgt=$p_r + 1;
三、删除节点：
找到所要删除节点的左右值$del_l,$del_r,删除所有左值>=$del_l,右值<=$del_r的节点；计算$v = $del_r - $del_l + 1;修改节点左值 > $del_l的左值为lft = lft - $v;修改节点右值 > $del_r 的右值为rgt = rgt - $v
四、获取子节点
1、不包含自己lft > $current_l and rgt < $current_r
2、包含自己lft >= $current_l and rgt <= $current_r
3、不包含自己的所有父类 lft < $current_l and rgt > $current_r
4、包含自己的所有父类 lft <= $current_l and rgt >= $current_r
五、计算子节点的数量
($current_r - $current_l - 1)/2
六、叶子节点
rgt = lft + 1
七、树的深度
SELECT node.*, (COUNT(parent.name) - 1) AS deep FROM tree AS node,tree AS parent WHERE node.lft BETWEEN parent.lft AND parent.rgt GROUP BY node.name ORDER BY node.lft 
八、检索单一路径
SELECT parent.* FROM tree AS node, tree AS parent WHERE node.lft BETWEEN parent.lft AND parent.rgt AND node.name = 'E' ORDER BY parent.lft;
九、获取直接子节点
SELECT * FROM (SELECT node.*, (COUNT(parent.name) - 1) AS deep FROM tree AS node,tree AS parent WHERE node.lft BETWEEN parent.lft AND parent.rgt GROUP BY node.name ORDER BY node.lft ) AS a WHERE a.deep<= 1;

 

<?php

/**
 * 基于左右值排序的无限分类算法 
 * 数据库结果为 
  CREATE TABLE om_catagory (
  CatagoryID int(10) unsigned NOT NULL auto_increment,
  Name varchar(50) default '',
  Lft int(10) unsigned NOT NULL default '0',
  Rgt int(10) unsigned NOT NULL default '0',
  PRIMARY KEY (id),
  KEY lft (lft),
  KEY rgt (rgt)
  )
 */
class sortclass {

    /**
     * Description 
     * @var        
     * @since     1.0 
     * @access    private 
     */
    var $db;

    /**
     * Description 
     * @var        
     * @since     1.0 
     * @access    private 
     */
    var $tablefix;

    /**
     * Short description.  
     * 构造函数,引入数据库操作类函数 
     * Detail description 
     * @param      none 
     * @global     none 
     * @since      1.0 
     * @access     private 
     * @return     void 
     * @update     date time 
     */
    function sortclass() {
        global $db;
        $this->db = $db;
        $this->tablefix = "om_";
    }

// end func  

    /**
     * Short description.  
     * 增加新的分类 
     * Detail description 
     * @param      none 
     * @global     none 
     * @since      1.0 
     * @access     private 
     * @return     void 
     * @update     date time 
     */
    function addsort($CatagoryID, $SortName) {
        if ($CatagoryID == 0) {
            $Lft = 0;
            $Rgt = 1;
        } else {
            $Result = $this->checkcatagory($CatagoryID);
            //取得父类的左值,右值  
            $Lft = $Result['Lft'];
            $Rgt = $Result['Rgt'];
            $this->db->query("UPDATE `" . $this->tablefix . "catagory` SET `Lft`=`Lft`+2 WHERE `Lft`>$Rgt");
            $this->db->query("UPDATE `" . $this->tablefix . "catagory` SET `Rgt`=`Rgt`+2 WHERE `Rgt`>=$Rgt");
        }

//插入  
        if ($this->db->query("INSERT INTO `" . $this->tablefix . "catagory` SET `Lft`='$Rgt',`Rgt`='$Rgt'+1,`Name`='$SortName'")) {
            //$this->referto("成功增加新的类别","JAVASCRIPT:HISTORY.BACK(1)",3);  
            return 1;
        } else {
            //$this->referto("增加新的类别失败了","JAVASCRIPT:HISTORY.BACK(1)",3);  
            return -1;
        }
    }

// end func  

    /**
     * Short description.  
     * 删除类别 
     * Detail description 
     * @param      none 
     * @global     none 
     * @since      1.0 
     * @access     private 
     * @return     void 
     * @update     date time 
     */
    function deletesort($CatagoryID) {
//取得被删除类别的左右值,检测是否有子类,如果有就一起删除  
        $Result = $this->checkcatagory($CatagoryID);
        $Lft = $Result['Lft'];
        $Rgt = $Result['Rgt'];
//执行删除  
        if ($this->db->query("DELETE FROM `" . $this->tablefix . "catagory` WHERE `Lft`>=$Lft AND `Rgt`<=$Rgt")) {
            $Value = $Rgt - $Lft + 1;
            //更新左右值  
            $this->db->query("UPDATE `" . $this->tablefix . "catagory` SET `Lft`=`Lft`-$Value WHERE `Lft`>$Lft");
            $this->db->query("UPDATE `" . $this->tablefix . "catagory` SET `Rgt`=`Rgt`-$Value WHERE `Rgt`>$Rgt");
            //$this->referto("成功删除类别","javascript:history.back(1)",3);  
            return 1;
        } else {
            //$this->referto("删除类别失败了","javascript:history.back(1)",3);  
            return -1;
        }
    }

// end func  

    /**
     * Short description.  
     * 1,所有子类,不包含自己;2包含自己的所有子类;3不包含自己所有父类4;包含自己所有父类 
     * Detail description 
     * @param      none 
     * @global     none 
     * @since      1.0 
     * @access     private 
     * @return     void 
     * @update     date time 
     */
    function getcatagory($CatagoryID, $type = 1) {
        $Result = $this->checkcatagory($CatagoryID);
        $Lft = $Result['Lft'];
        $Rgt = $Result['Rgt'];
        $SeekSQL = "SELECT * FROM `" . $this->tablefix . "catagory` WHERE ";
        switch ($type) {
            case "1":
                $condition = "`Lft`>$Lft AND `Rgt`<$Rgt";
                break;
            case "2":
                $condition = "`Lft`>=$Lft AND `Rgt`<=$Rgt";
                break;
            case "3":
                $condition = "`Lft`<$Lft AND `Rgt`>$Rgt";
                break;
            case "4":
                $condition = "`Lft`<=$Lft AND `Rgt`>=$Rgt";
                break;
            default :
                $condition = "`Lft`>$Lft AND `Rgt`<$Rgt";
                ;
        }
        $SeekSQL .= $condition . " ORDER BY `Lft` ASC";
        $Sorts = $this->db->getrows($SeekSQL);
        return $Sorts;
    }

// end func  

    /**
     * Short description.  
     * 取得直属父类 
     * Detail description 
     * @param      none 
     * @global     none 
     * @since      1.0 
     * @access     private 
     * @return     void 
     * @update     date time 
     */
    function getparent($CatagoryID) {
        $Parent = $this->getcatagory($CatagoryID, 3);
        return $Parent;
    }

// end func  
    /**
     * Short description.  
     * 移动类,如果类有子类也一并移动 
     * Detail description 
     * @param      none 
     * @global     none 
     * @since      1.0 
     * @access     private 
     * @return     void 
     * @update     date time 
     */

    function movecatagory($SelfCatagoryID, $ParentCatagoryID) {
        $SelfCatagory = $this->checkcatagory($SelfCatagoryID);
        $NewCatagory = $this->checkcatagory($ParentCatagoryID);

        $SelfLft = $SelfCatagory['Lft'];
        $SelfRgt = $SelfCatagory['Rgt'];
        $Value = $SelfRgt - $SelfLft;
//取得所有分类的ID方便更新左右值  
        $CatagoryIDS = $this->getcatagory($SelfCatagoryID, 2);
        foreach ($CatagoryIDS as $v) {
            $IDS[] = $v['CatagoryID'];
        }
        $InIDS = implode(",", $IDS);

        $ParentLft = $NewCatagory['Lft'];
        $ParentRgt = $NewCatagory['Rgt'];
//print_r($InIDS);  
//print_r($NewCatagory);  
//print_r($SelfCatagory);  
//exit;  
        if ($ParentRgt > $SelfRgt) {
            $UpdateLeftSQL = "UPDATE `" . $this->tablefix . "catagory` SET `Lft`=`Lft`-$Value-1 WHERE `Lft`>$SelfRgt AND `Rgt`<=$ParentRgt";
            $UpdateRightSQL = "UPDATE `" . $this->tablefix . "catagory` SET `Rgt`=`Rgt`-$Value-1 WHERE `Rgt`>$SelfRgt AND `Rgt`<$ParentRgt";
            $TmpValue = $ParentRgt - $SelfRgt - 1;
            $UpdateSelfSQL = "UPDATE `" . $this->tablefix . "catagory` SET `Lft`=`Lft`+$TmpValue,`Rgt`=`Rgt`+$TmpValue WHERE `CatagoryID` IN($InIDS)";
        } else {
            $UpdateLeftSQL = "UPDATE `" . $this->tablefix . "catagory` SET `Lft`=`Lft`+$Value+1 WHERE `Lft`>$ParentRgt AND `Lft`<$SelfLft";
            $UpdateRightSQL = "UPDATE `" . $this->tablefix . "catagory` SET `Rgt`=`Rgt`+$Value+1 WHERE `Rgt`>=$ParentRgt AND `Rgt`<$SelfLft";
            $TmpValue = $SelfLft - $ParentRgt;
            $UpdateSelfSQL = "UPDATE `" . $this->tablefix . "catagory` SET `Lft`=`Lft`-$TmpValue,`Rgt`=`Rgt`-$TmpValue WHERE `CatagoryID` IN($InIDS)";
        }
        $this->db->query($UpdateLeftSQL);
        $this->db->query($UpdateRightSQL);
        $this->db->query($UpdateSelfSQL);
//$this->referto("成功移动类别","javascript:history.back(1)",3);  
        return 1;
    }

// end func  

    /**
     * Short description.  
     * 
     * Detail description 
     * @param      none 
     * @global     none 
     * @since      1.0 
     * @access     private 
     * @return     void 
     * @update     date time 
     */
    function checkcatagory($CatagoryID) {
//检测父类ID是否存在  
        $SQL = "SELECT * FROM `" . $this->tablefix . "catagory` WHERE `CatagoryID`='$CatagoryID' LIMIT 1";
        $Result = $this->db->getrow($SQL);
        if (count($Result) < 1) {
            $this->referto("父类ID不存在,请检查", "javascript:history.back(1)", 3);
        }
        return $Result;
    }

// end func  

    /**
     * Short description.  
     * 
     * Detail description 
     * @param      none 
     * @global     none 
     * @since      1.0 
     * @access     private 
     * @return     array($Catagoryarray,$Deep) 
     * @update     date time 
     */
    function sort2array($CatagoryID = 0) {
        $Output = array();
        if ($CatagoryID == 0) {
            $CatagoryID = $this->getrootid();
        }
        if (empty($CatagoryID)) {
            return array();
            exit;
        }
        $Result = $this->db->query('SELECT Lft, Rgt FROM `' . $this->tablefix .
                'catagory` WHERE `CatagoryID`=' . $CatagoryID);
        if ($Row = $this->db->fetch_array($Result)) {
            $Right = array();
            $Query = 'SELECT * FROM `' . $this->tablefix .
                    'catagory` WHERE Lft BETWEEN ' . $Row['Lft'] . ' AND ' .
                    $Row['Rgt'] . ' ORDER BY Lft ASC';

            $Result = $this->db->query($Query);
            while ($Row = $this->db->fetch_array($Result)) {
                if (count($Right) > 0) {
                    while ($Right[count($Right) - 1] < $Row['Rgt']) {
                        array_pop($Right);
                    }
                }
                $Output[] = array('Sort' => $Row, 'Deep' => count($Right));
                $Right[] = $Row['Rgt'];
            }
        }
        return $Output;
    }

// end func  

    /**
     * Short description.  
     * 
     * Detail description 
     * @param      none 
     * @global     none 
     * @since      1.0 
     * @access     private 
     * @return     void 
     * @update     date time 
     */
    function getrootid() {
        $Query = "SELECT * FROM`" . $this->tablefix . "catagory` ORDER BY `Lft` ASC LIMIT 1";
        $RootID = $this->db->getrow($Query);
        if (count($RootID) > 0) {
            return $RootID['CatagoryID'];
        } else {
            return 0;
        }
    }

// end func  
}

// end class  
?>

优化mysql左右值无限极分类

CREATE TABLE `tree` (
  `id` INT(10) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(255) NOT NULL,
  `pid` INT(10) NOT NULL DEFAULT '0' COMMENT '父ID',
  `lft` INT(10) NOT NULL DEFAULT '0' COMMENT '左节点',
  `rgt` INT(10) NOT NULL DEFAULT '0' COMMENT '右节点',
  `level` INT(10) NOT NULL DEFAULT '0' COMMENT '深度',
  `status` INT(1) NOT NULL DEFAULT '0' COMMENT '逻辑删除 1是 0否',
  PRIMARY KEY (`id`),
  KEY `pid` (`pid`),
  KEY `lft` (`lft`),
  KEY `rgt` (`rgt`),
  KEY `level` (`level`),
  KEY `status` (`status`)
) ENGINE=INNODB  DEFAULT CHARSET=utf8;

第一个节点
INSERT INTO tree VALUES (NULL, 'A', 0, 0, 1, 0, 0);
SELECT * FROM tree

父节点左值$a_l = 0; 父节点右值$a_r = 1; 父节点深度$p_h=0; 父节点ID $pid=1
第二个节点（A的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 1;#lft > $a_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 1;#rgt >= $a_r
INSERT INTO tree VALUES (NULL, 'B', 1, 1, 1+1, 0+1, 0);#(NULL, 'B', $pid, $a_r, $a_r + 1, $p_h + 1, 0);

$a_l = 0; $a_r = 3; 父节点深度$p_h=0; 父节点ID $pid=1
第三个节点（A的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 3;#lft > $a_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 3;#rgt >= $a_r
INSERT INTO tree VALUES (NULL, 'C', 1, 3, 3+1, 0+1, 0);#(NULL, 'C', $pid, $a_r, $a_r + 1, $p_h + 1, 0);

$a_l = 0; $a_r = 5;父节点深度$p_h=0; 父节点ID $pid=1
第四个节点（A的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 5;#lft > $a_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 5;#rgt >= $a_r
INSERT INTO tree VALUES (NULL, 'D', 1, 5, 5+1, 0+1, 0);#(NULL, 'D', $pid, $a_r, $a_r + 1, $p_h + 1, 0);

$b_l = 1; $b_r = 2;父节点深度$p_h=1; 父节点ID $pid=2
第五个节点（B的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 2;#lft > $b_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 2;#rgt >= $b_r
INSERT INTO tree VALUES (NULL, 'E', 2, 2, 2+1, 1+1, 0);#(NULL, 'E', $pid, $b_r, $b_r + 1, $p_h + 1, 0);

$b_l = 1; $b_r = 4;父节点深度$p_h=1; 父节点ID $pid=2
第六个节点（B的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 4;#lft > $b_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 4;#rgt >= $b_r
INSERT INTO tree VALUES (NULL, 'F', 2, 4, 4+1, 1+1, 0);#(NULL, 'F', $pid, $b_r, $b_r + 1, $p_h + 1, 0);

$e_l = 2; $e_r = 3;父节点深度$p_h=2; 父节点ID $pid=5
第七个节点（E的子节点）
UPDATE tree SET lft = lft + 2 WHERE lft > 3;#lft > $e_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 3;#rgt >= $e_r
INSERT INTO tree VALUES (NULL, 'G', 5, 3, 3+1, 2+1, 0);#(NULL, 'G', $pid, $e_r, $e_r + 1, $p_h + 1, 0);

$c_l = 9; $c_r = 10;父节点深度$p_h=1; 父节点ID $pid=3
第八个节点(C的子节点)
UPDATE tree SET lft = lft + 2 WHERE lft > 10;#lft > $c_r
UPDATE tree SET rgt = rgt + 2 WHERE rgt >= 10;#rgt >= $c_r
INSERT INTO tree VALUES (NULL, 'H', 3, 10, 10+1, 1+1, 0);#(NULL, 'G', $pid, $c_r, $c_r + 1, $p_h + 1, 0);

$e_l = 2; $e_r = 5;
删除节点（E节点）
$v = 5 - 2 + 1 = 4;#$v = $e_r - $e_l + 1; 
DELETE FROM tree WHERE lft >= 2 AND rgt <= 5;#lft >= $e_l and rgt <= $e_r
UPDATE tree SET lft = lft - 4 WHERE lft > 2;#lft = lft - $v where lft > $e_l
UPDATE tree SET rgt = rgt - 4 WHERE rgt > 5;#rgt = rgt - $v WHERE rgt > $e_r

$b_l = 1; $b_r = 4;
删除节点（B节点）
$v = 4 - 1 + 1 = 4;#$v = $b_r - $b_l + 1; 
DELETE FROM tree WHERE lft >= 1 AND rgt <= 4;#lft >= $b_l and rgt <= $b_r
UPDATE tree SET lft = lft - 4 WHERE lft > 1;#lft = lft - $v where lft > $b_l
UPDATE tree SET rgt = rgt - 4 WHERE rgt > 4;#rgt = rgt - $v WHERE rgt > $b_r

总结：
一、根节点
lft=0,rgt=1,level=0
二、添加子节点:
找到父节点的右值$p_r，所有节点左值 > $p_r 的左值 + 2；所有节点右值 >= $p_r的右值 +2;插入新节点lft=$p_r,rgt=$p_r + 1,level=p_level+1;
三、删除节点：
找到所要删除节点的左右值$del_l,$del_r,删除所有左值>=$del_l,右值<=$del_r的节点；计算$v = $del_r - $del_l + 1;修改节点左值 > $del_l的左值为lft = lft - $v;修改节点右值 > $del_r 的右值为rgt = rgt - $v
四、获取子节点
1、不包含自己lft > $current_l and rgt < $current_r
2、包含自己lft >= $current_l and rgt <= $current_r
3、不包含自己的所有父类 lft < $current_l and rgt > $current_r
4、包含自己的所有父类 lft <= $current_l and rgt >= $current_r
五、计算子节点的数量
($current_r - $current_l - 1)/2
六、叶子节点
rgt = lft + 1
七、树的深度
就是level
八、检索单一路径
E的
select * from tree where lft <= 2 and rgt >= 5
九、获取直接子节点
SELECT * FROM tree WHERE lft > 1 AND rgt < 8 AND LEVEL = 2

wiscourper_
关注
专栏目录
MySQL无限极分类数据表的设计
Rookie_Or_Veteran的博客
07-22 8986
无限级分类表设计  　　实际上我们在开发过程中，就拿商品类别来说，它还可以有更多的延伸，我们先来举一个简单的例子，比如图书，他的下面还可以分小说、文学等，在小说下面还可以分为言情小说、科幻小说等，还可以再往下一级一级继续分，那么这种分类就属于无限极分类，那么无限极分类表该如何去设计，理论上说我们可以设计很多张表，但是随着分类的逐步增多，表的数目就会越来越多，所以无限极分类表往往采用另外一种形式。
mysql 预查询-无限极分类
xudejun的博客
07-19 368
class Test extends Controller{ public function index(){ $id = input('id'); //$this->setparent(); $this->setchild($id); } public function setparent(){ $list = []; $list = db('ce')->insert([ .
mysql 无限级分类实现思路
12-15
第一种方案： 使用递归算法，也是使用频率最多的，大部分开源程序也是这么处理，不过一般都只用到四级分类。这种算法的数据库结构设计最为简单。category表中一个字段id，一个字段fid(父id)。这样可以根据WHERE id = fid来判断上一级内容，运用递归至最顶层。 分析：通过这种数据库设计出的无限级，可以说读取的时候相当费劲，所以大部分的程序最多3-4级分类，这就足以满足需求，从而一次性读出所有的数据，再对得到数组或者对象进行递归。本身负荷还是没太大问题。但是如果分类到更多级，那是不可取的办法。 这样看来这种分类有个好处，就是增删改的时候轻松了…然而就二级分类而言，采用这种算法就应该算
mysql部门无限分类_mysql 无限级分类
weixin_42349214的博客
01-30 152
两种思路吧，递归 和 非递归递归$arr = [1=>['id'=>1,'pid'=>0],2=>['id'=>2,'pid'=>0],3=>['id'=>3,'pid'=>1],4=>['id'=>4,'pid'=>1],5=>['id'=>5,'pid'=>0],6=>['id'=>6,'pi...
mysql 无限极分类
weixin_30294295的博客
01-05 228
1 import pymysql 2 class Type: 3 def __init__(self): 4 # 连接数据库 5 self.bankData = pymysql.connect("127.0.0.1", "root", "123123", "user") 6 # 设置字符编码 7 ...
MySQL无限分类
xiaomu_a的博客
04-02 740
无限分类：不管什么分类就放在分类表中 CREATE TABLE loop_category ( id INT PRIMARY KEY AUTO_INCREMENT, NAME VARCHAR(20), pid INT ); INSERT INTO loop_category (NAME, pid) VALUES ('手机', NULL), ('电视', NULL), ('空调', NUL...
php mysql数据库无限分类类库.zip
07-11
这是一个php无限分类代码，比较完整理包括了数据库是mysql的,有增加、删除、编辑、移动的功能,同时还提供数据库sql表结构。需要的朋友可以参考下，方便大家学习php。
mysql的无限分类问题_MySQL无限分类
weixin_33469623的博客
02-28 112
无限分类：不管什么分类就放在分类表中CREATE TABLE loop_category (id INT PRIMARY KEY AUTO_INCREMENT,NAME VARCHAR(20),pid INT);INSERT INTO loop_category (NAME, pid) VALUES ('手机', NULL), ('电视', NULL), ('空调', NULL);INSERT I...
MySQL的多级/无限级分类
qq_36426390的博客
02-22 1897
MySQL多级列表的一种实践
MYSQL无限分类算法文档
07-27
MYSQL无限分类算法技术文档——MYSQL中分层数据的管理，不解MYSQL高级数据管理的相关技巧，包括了一些必要的SQL语句和高级数据管理的讲解，像邻接表模型、检索整树、检索所有叶子节点、检索单一路径、邻接表模型的局限性、嵌套集合(Nested Set)模型、检索子树的深度、嵌套集合模型中集合函数的应用、删除节点等。
mysql无限级分类表设计
wen_binobject的博客
02-13 1261
1.先创建表 CREATE TABLE tdb_goods_types( type_id SMALLINT UNSIGNED PRIMARY KEY AUTO_INCREMENT, type_name VARCHAR(20) NOT NULL, parent_id SMALLINT UNSIGNED NOT NULL DEFAULT 0 ); 2.写入数据 INSERT tdb_goods_t...
[中级]微信开发工具与Gitee实现代码管理
私信可回答各种问题~
05-22 1164
微信开发工具-版本管理与Gitee实现代码管理同步更新
LinkedList源码分析(JDK1.8)
weixin_44127838的博客
09-08 246
简介： LinkedList底层数据结构为双向链表，与ArrayList相同的是，其是list接口的实现类，意味着其存储元素是连续且可重复的。 LinkedList继承于AbstractSequentialList类 LinkedList实现了Deque接口，代表其支持队列操作；实现了Cloneable，代表其可克隆；实现了 public class LinkedList<E> extends AbstractSequentialList<E>...
推荐两种MySQL无限级分类设计方案
2023年最新地推相关信息
04-08 1829
软件开发过程中我们经常会遇到各种各样多级的数据结构需求。刚开始与产品沟通的最多只支持3级。后期根据需求的迭代3级变成多级再变成无限级。有时候产品为了减少麻烦产品初级就会定义支持无限的分类结构。分类的产品需求非常简单可能就一句话支持无限级的分类数据结构。但分类的代码开发繁琐麻烦有时候还有点复杂。今天为大家介绍两种无限级分类设计方案。大家可以根据自身的业务需求合理使用解决方案。第一种方案：父ID方式1...
mysql select 无限极_查询-mysql无限极分类排序问题
weixin_29617841的博客
01-27 489
表是这样设计的2，4,5字段请无视现在要查询出来这样格式的数据一级分类二级分类A三级分类A三级分类B二级分类B三级分类A三级分类B我使用的sql为 select * from vn_erp_healthprice order by sortssorts字段为varchar类型查询的结果如下排序结果满足业务要求,但为什么1-11排在1-2前面还有 根据字符串排序这是个什么原理来着 好久没用过这种分...
mysql无限极分类_mysql中无限极分类的代码实现
weixin_30610943的博客
01-19 624
本篇文章给大家带来的内容是关于mysql中无限极分类的代码实现，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。我也是从别的地方找来的，分析后发现挺不错的，特来分享。无法发图只能简单处理：id name pid path1 ...
Mysql 无限分类3种方案
weixin_34097242的博客
04-17 215
网上流传版 第一种方案： 　　使用递归算法，也是使用频率最多的，大部分开源程序也是这么处理，不过一般都只用到四级分类。这种算法的数据库结构设计最为简单。category表中一个字段id，一个字段fid(父id)。这样可以根据WHERE id = fid来判断上一级内容，运用递归至最顶层。 　　分析：通过这种数据库设计出的无限级，可以说读取的时候相当费劲，所以大部分的程序最多3-4级分类，这就...
分类中计算数量
是日已过，命亦随减的博客
10-09 175
思路： 把分类列表和图片列表全部搜出来。 然后用一个方法把这两个数组整合。 /** * 开放图库分类 */ public function galleryOpenCategory() { $gallery_open_cates_info = db('gallery_open_cates')->field('id,name,parent_id')->select(); $gallery_open_cates_info =
PHP无限极分类表设计与手动排序实现
无限极分类排序技术概述 在无限极分类系统中，排序是非常重要的一步骤。无限极分类排序技术是指在无限极分类系统中对分类的排序和排列。今天，我们将对无限极分类排序技术进行详细的介绍和分析。 **什么是无限极...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值