1.業務場景

有如下樹形結構:
+—0
+—1
+—2
+—4
+—5
+—3

如果刪除某個父節點，則其子節點，以及其子節點的子節點，以此類推，需要全部刪除。

2.Java實現

使用Map儲存樹形結構的資料，id為map的key，pid為樹形結構的value。

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 為排序欄位。

建表並插入資料：

CREATE TABLE treeNodes
(
 id INT PRIMARY KEY,
 pid INT
);
INSERT INTO treeNodes VALUES 
(1, 0),
(2, 1),
(3, 1),
(4, 2),
(5, 4);

建立並呼叫儲存過程：

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);

下面是需要刪除的子節點：
//

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