使用递归删除树形结构的所有子节点(java和mysql实现)

时间:2022-08-28 21:31:09

1.业务场景

有如下树形结构:
+—0
+—1
+—2
+—4
+—5
+—3

如果删除某个父节点,则其子节点,以及其子节点的子节点,以此类推,需要全部删除。

2.Java实现

使用Map存储树形结构的数据,id为map的key,pid为树形结构的value。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
 
public class TreeNodes {
  public static void main(String[] args) {
    test();
  }
 
  //测试removeSons方法
  public static void test(){
 
    //原始的Map
    Map<Integer, Integer> t=new HashMap<Integer, Integer>();
    //  ID PID
    t.put(1, 0);
    t.put(2, 1);
    t.put(3, 1);
    t.put(4, 2);
    t.put(5, 4);
    System.out.println("—— —— —— —— —— ——原始的Map —— —— —— —— —— —— ——");
 
    Set<Integer> keys=t.keySet();
    Iterator<Integer> iterator=keys.iterator();
    System.out.println("ID —— PID");
    while(iterator.hasNext()){
      Integer i=iterator.next();
      System.out.println(i+" —— "+t.get(i)); 
    }
 
    int k=2;
    //递归删除k的所有子节点
    System.out.println("—— —— —— —— —— ——删除掉的节点 —— —— —— —— —— —— ——");
    removeTreeNodes(t,k);
    //删除k节点本身
    t.remove(k);
    System.out.println();
    System.out.println("—— —— —— —— —— —— 递归删除["+k+"]的所有子节点后的Map —— —— ");
 
    iterator=keys.iterator();
    System.out.println("ID —— PID");
    while(iterator.hasNext()){
      Integer i=iterator.next();
      System.out.println(i+" —— "+t.get(i));
    }
  }
 
  //递归删除所有的子节点
  public static Map<Integer, Integer> removeTreeNodes(Map<Integer, Integer> t,Integer k){
    //所有需要删除的子节点
    List<Integer> sons=new ArrayList<Integer>();
    sons.add(k);
    List<Integer> temp=new ArrayList<Integer>();
    //循环递归删除,所有以k为父节点的节点
    while(true){   
      for(Integer s:sons){
        Set<Integer> keys=t.keySet();
        Iterator<Integer> it=keys.iterator();
        while(it.hasNext()){
          Integer n=it.next();
          //如果父节点(即Map的value)为需要删除的节点,则记录此节点,并在Map中删除
          if(t.get(n)==s){
            temp.add(n);
            it.remove();
            System.out.println("删除了ID=["+n+"]的节点,其父节点为["+s+"]");
          }
        }
      }
 
      //如果此节点包含子节点,则将子节点赋值给sons;否则表示所有子节点已经删除,结束循环
      if(temp.size()>0){
        sons=temp; 
        temp=new CopyOnWriteArrayList<Integer>();
      }else{
        break;
      }
    }
 
    return t;
  }
}

3.SQL实现

利用存储过程,将所有子节点存储到临时表里。

存储过程执行完后会产生一个临时表,id为需要删除的子节点id,nLevel 为节点深度,sCort 为排序字段。

建表并插入数据:

?
1
2
3
4
5
6
7
8
9
10
11
CREATE TABLE treeNodes
(
 id INT PRIMARY KEY,
 pid INT
);
INSERT INTO treeNodes VALUES
(1, 0),
(2, 1),
(3, 1),
(4, 2),
(5, 4);

创建并调用存储过程:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
DELIMITER//
 
DROP PROCEDURE IF EXISTS removeTreeNodes//
 
CREATE PROCEDURE removeTreeNodes(IN rootid INT)
 BEGIN
 DECLARE LEVEL INT ;
 DROP TABLE IF EXISTS tempNodes;
 CREATE TABLE tempNodes (
  id INT,
  nLevel INT,
  sCort VARCHAR(8000)
 );
 SET LEVEL=0 ;
 INSERT INTO tempNodes SELECT id,LEVEL,ID FROM treeNodes WHERE PID=rootid;
 WHILE ROW_COUNT()>0 DO
  SET LEVEL=LEVEL+1 ;
  INSERT INTO tempNodes
  SELECT A.ID,LEVEL,CONCAT(B.sCort,A.ID) FROM treeNodes A,tempNodes B
  WHERE A.PID=B.ID AND B.nLevel=LEVEL-1 ;
 END WHILE;
 END;
//
DELIMITER ;
 
CALL removeTreeNodes(0);

下面是需要删除的子节点:

?
1
2
3
4
SELECT CONCAT(SPACE(B.nLevel*2),'+--',A.id)
FROM treeNodes A,tempNodes B
WHERE A.ID=B.ID
ORDER BY B.sCort;

以上这篇使用递归删除树形结构的所有子节点(java和mysql实现)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持服务器之家。

原文链接:http://blog.csdn.net/sinat_26342009/article/details/51907374