介紹：
什麼是左右值無限級分類：
左右值無限級分類，也稱為預排序樹無限級分類，是一種有序的樹狀結構，位於這些樹狀結構中的每一個節點都有一個“左值”和“右值”，其規則是：每一個後代節點的左值總是大於父類，右值總是小於父級，右值總是小於左值。處於這些結構中的每一個節點，都可以輕易的算出其祖先或後代節點。因此，可以用它來實現無限分類。
左右值無限分類的優缺點：
優點：
通過一條SQL就可以獲取所有的祖先或後代，這在複雜的分類中非常必要
通過簡單的四則運算就可以得到後代的數量
缺點
分類操作麻煩

無法簡單的獲取子代（請看請“子代”和"後代"）

1. 測試資料準備

CREATE TABLE `nested_category` (
  `category_id` int(10) NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `name` varchar(18) COLLATE utf8_unicode_ci NOT NULL DEFAULT '' COMMENT '名稱',
  `lft` int(4) NOT NULL,
  `rgt` int(4) NOT NULL,
  KEY `category_id` (`category_id`)
) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

INSERT INTO `nested_category` VALUES 
(1,'商品',1,26),
(2,'化妝品',2,7),
(3,'食品',8,9),
(4,'酒',10,15),
(5,'服裝',16,17),
(6,'家電',18,23),
(7,'鞋帽',24,25),
(8,'面霜',3,4),
(9,'面膜',5,6),
(10,'白酒',11,12),
(11,'紅酒',13,14),
(12,'冰箱',19,20),
(13,'空調',21,22);

資料檢視
mysql> select * from nested_category;
+-------------+-----------+-----+-----+
| category_id | name      | lft | rgt |
+-------------+-----------+-----+-----+
|           1 | 商品    |   1 |  26 |
|           2 | 化妝品 |   2 |   7 |
|           3 | 食品    |   8 |   9 |
|           4 | 酒       |  10 |  15 |
|           5 | 服裝    |  16 |  17 |
|           6 | 家電    |  18 |  23 |
|           7 | 鞋帽    |  24 |  25 |
|           8 | 面霜    |   3 |   4 |
|           9 | 面膜    |   5 |   6 |
|          10 | 白酒    |  11 |  12 |
|          11 | 紅酒    |  13 |  14 |
|          12 | 冰箱    |  19 |  20 |
|          13 | 空調    |  21 |  22 |
+-------------+-----------+-----+-----+
 

2. 插入分類思路

分析一下兩種情況：
插入最頂級節點：它的左右值與該樹中最大的右值有關：左值=最大右值+1，右值=最大右值+2，你可以自己模擬一下；
插入子節點：它的左右值與它的父級有關：左值=父級的右值，右值=當前的左值+1，這時要更新的資料有：父級的右值，所有左值大於父級左級，右值大於低階右值的節點左右值都應該+2；
下載例項

3. 獲取所有的後代節點

從圖中可以看出找出某個節點的所有子節點，lft 大於左值 rgt 小於右值

select * from nested_category where lft > 18 and rgt < 23;
+-------------+--------+-----+-----+
| category_id | name   | lft | rgt |
+-------------+--------+-----+-----+
|          12 | 冰箱 |  19 |  20 |
|          13 | 空調 |  21 |  22 |
+-------------+--------+-----+-----+
2 rows in set (0.00 sec)
 

4. 計算所有子類的數量

有人認為使用 count 配合上面的語句就可以算出，這當然是可以的，但有更快的方式：每有子類節點中每個節點佔用兩個值，而這些值都是不一樣且連續的，那些就可以計算出子代的數 量=(右值-左值-1)/2。減少1的原因是排除該節點，你可以想像一個，一個單節點，左值是1，右值是2，沒有子類節點，而這時它的右值-左值=1.

5. 檢索單一路徑

方法：通過上述結果可以發子類的lft,rgt 都可以父類的lft,rgt之前

select 
	parent.name,
	parent.category_id, 
	parent.lft,
	parent.rgt
from 
	nested_category as node, nested_category as parent 
where 
	node.lft between parent.lft and parent.rgt and node.name = '空調' 
	order by parent.lft;

+--------+-------------+-----+-----+
| name   | category_id | lft | rgt |
+--------+-------------+-----+-----+
| 商品 |           1 |   1 |  26 |
| 家電 |           6 |  18 |  23 |
| 空調 |          13 |  21 |  22 |
+--------+-------------+-----+-----+
3 rows in set (0.00 sec)
 

6. 檢索所有葉子節點

檢索出所有的葉子節點，使用巢狀集合模型的方法比鄰接表模型的LEFT JOIN方法簡單多了。如果你仔細得看了nested_category表，你可能已經注意到葉子節點的左右值是連續的。要檢索出葉子節點，我們只要查詢滿足rgt=lft+1的節點：

select 
	*
from 
	nested_category
where rgt = lft + 1;
+-------------+--------+-----+-----+
| category_id | name   | lft | rgt |
+-------------+--------+-----+-----+
|           3 | 食品 |   8 |   9 |
|           5 | 服裝 |  16 |  17 |
|           7 | 鞋帽 |  24 |  25 |
|           8 | 面霜 |   3 |   4 |
|           9 | 面膜 |   5 |   6 |
|          10 | 白酒 |  11 |  12 |
|          11 | 紅酒 |  13 |  14 |
|          12 | 冰箱 |  19 |  20 |
|          13 | 空調 |  21 |  22 |
+-------------+--------+-----+-----+
9 rows in set (0.01 sec)

7. 獲取分類的深度

select 
	node.name as name,  (count(parent.name) - 1) as deep
from 
	nested_category as node,
	nested_category as parent
where node.lft between parent.lft and parent.rgt
group by node.name
order by node.lft
+-----------+------+
| name      | deep |
+-----------+------+
| 商品    |    0 |
| 化妝品 |    1 |
| 面霜    |    2 |
| 面膜    |    2 |
| 食品    |    1 |
| 酒       |    1 |
| 白酒    |    2 |
| 紅酒    |    2 |
| 服裝    |    1 |
| 家電    |    1 |
| 冰箱    |    2 |
| 空調    |    2 |
| 鞋帽    |    1 |
+-----------+------+
13 rows in set (0.03 sec)

8. 檢索節點的直接子節點

可以想象一下，你在零售網站上呈現電子產品的分類。當用戶點選分類後，你將要呈現該分類下的產品，同時也需列出該分類下的直接子分類，而不是該分類下的全部分類。為此，我們只呈現該節點及其直接子節點，不再呈現更深層次的節點
如上述獲取深度的例子，可以根椐深度來小於等於1獲得直接子節點

select * from (
	select 
		node.name as name,  
		(count(parent.name) - 1) as deep 
	from 
		nested_category as node,
		nested_category 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; 
+-----------+------+
| name      | deep |
+-----------+------+
| 商品    |    0 |
| 化妝品 |    1 |
| 食品    |    1 |
| 酒       |    1 |
| 服裝    |    1 |
| 家電    |    1 |
| 鞋帽    |    1 |
+-----------+------+
7 rows in set (0.00 sec)

9. 刪除分類
刪除分類是基礎操作,刪除分類的處理過程跟節點在分層中所處的位置是有關，在刪除時需要考慮兩種情況，1 刪除單個的葉子分類  2 刪除子節點  相對而言刪除單個的葉子分類比較簡單,
就好比新增的逆過程,我們刪除節點的同時該節點右邊所有的左右值和該父節點的右值都會減去該節點的寬度值

lock table nested_category write;
select @myleft := lft, @myright := rgt, @mywidth := rgt-lft+1 from nested_category where name = '家電';
delete from nested_category where lft between @myleft and @myright;
update nested_category set lft = lft - @mywidth where rgt > @myright
update nested_category set rgt = rgt - @mywidth where lft > @myright
unlock tables;

轉載請註明來源：http://blog.csdn.net/i_bruce/article/details/41558063