精华内容
下载资源
问答
  • 删除所有子节点,oracle特有的写法: delete from ap_folder where folder_id in (select folder_id from ap_foleder start id='1' connect by prior folder_id = parent_id )

    删除所有子节点,oracle特有的写法:
    delete from ap_folder where folder_id in (select folder_id from ap_foleder start id='1' connect by prior
    folder_id = parent_id )

    展开全文
  • 在二叉排序搜索中,要删除子节点的节点的话。 有两种情况 第一种-要删除的节点有一个子节点: 1、判断子节点是左节点还是右节点 2、判断出来是左节点的话 2.1、看看其父节点的左节点是不是我要删除的节点 2.2、...

    在二叉排序搜索树中,要删除有子节点的节点的话。
    有两种情况
    第一种-要删除的节点有一个子节点:
    1、判断子节点是左节点还是右节点
    2、判断出来是左节点的话
    2.1、看看其父节点的左节点是不是我要删除的节点
    2.2、是的话就将其父节点的左节点设置为其左子节点
    2.3、如果不是左节点的话,就将其父节点的右节点设置为其左子节点
    3、如果是右子节点的话,同理。但是要注意将左右设置清楚
    第二种-要删除的节点有两个子节点:
    1、找到其的后继节点
    2、将其后继节点的值赋值给要删除的节点的值

    代码实现

    节点类

    package com.demo4;
    
    public class Node {
        int value;
        Node left;
        Node right;
        public Node(int value){
            this.value = value;
        }
    
        public void add(Node node) {
            if(node == null){
                return;
            }
            if(node.value > this.value){
                if(this.right == null){
                    this.right = node;
                }
                else{
                    this.right.add(node);
                }
            }
            if(node.value < this.value){
                if(this.left == null){
                    this.left = node;
                }
                else{
                    this.left.add(node);
                }
            }
        }
    
        public void middleshow(Node node) {
            if(node == null){
                return;
            }
            middleshow(node.left);
            System.out.println(node.value);
            middleshow(node.right);
        }
    
        public Node search(int value) {
            if(this.value == value){
                return this;
            }
            else if(value < this.value){
                if(this.left == null) {
                    return null;
                }
                return left.search(value);
            }
            else{
                if(this.right == null){
                    return null;
                }
                return right.search(value);
            }
        }
    
        public Node searchParent(int value) {
            if((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)){
                return this;
            }
            else{
                if(this.value > value && this.left != null){
                    return this.left.searchParent(value);
                }
                else if(this.right != null){
                    return this.right.searchParent(value);
                }
                else{
                    return null;
                }
            }
        }
    }
    
    

    二叉排序树类

    package com.demo4;
    
    public class BinarySearchTree {
        Node root;
        public void add(Node node){
            if(root == null){
                root = node;
            }
            else{
                root.add(node);
            }
        }
        public void middleshow(){
            if(root == null){
                System.out.println("This tree is Empty.");
                return;
            }
            else{
                root.middleshow(root);
            }
        }
        public Node search(int value){
            if(root == null) return null;
            else{
                return root.search(value);
            }
        }
        public Node searchParent(int value){
            if(root == null) return null;
            else{
                return root.searchParent(value);
            }
        }
        public void delete(int value){
            if(root == null){
                return;
            }
    
            else{
                Node target = search(value);
                if(target == null){
                    return;
                }
                Node parent = searchParent(value);
                if(target.left == null && target.right == null){
                    if(parent.left.value == value){
                        parent.left = null;
                    }
                    else{
                        parent.right = null;
                    }
                }//有两个子节点
                else if(target.left != null && target.right != null){
                    int min = deleteMin(target.right);
                    target.value = min;
                }
                else {
                    if(target.left != null){
                        if(parent.left.value == value){
                            parent.left = target.left;
                        }
                        else{
                            parent.right = target.left;
                        }
                    }
                    else{
                        if(parent.right.value == value){
                            parent.right = target.right;
                        }
                        else{
                            parent.left = target.right;
                        }
                    }
                }
    
            }
    
    
        }
    
        private int deleteMin(Node node) {
            Node target = node;
            while (target.left != null){
                target = node.left;
            }
            delete(target.value);
            return target.value;
        }
    }
    
    

    测试类

    public class testBST {
        public static void main(String[] args) {
            int [] arr = new int[] {7,3,10,12,5,1,9};
            BinarySearchTree bst = new BinarySearchTree();
            for(int i : arr){
                bst.add(new Node(i));
            }
            System.out.println(bst.root.value);
            bst.delete(bst.root.value);
            System.out.println("**************************************************删除后");
            System.out.println(bst.root.value);
    

    测试结果
    我删除的是root节点来测试
    在这里插入图片描述

    展开全文
  • 下面小编就为大家带来一篇使用递归删除树结构的所有子节点(java和mysql实现)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 1.业务场景有如下结构: +—0 +—1 +—2 +—4 +—5 +—3 如果如果删除某个父节点,则其子节点,已经子节点子节点,以此类推,需要全部删除

    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;
    

    查询结果

    展开全文
  • Java递归删除树结构节点

    千次阅读 2017-08-27 22:11:00
    1.当删除子节点后其父节点没有其他子节点时,应将其父节点标志设置为false,但是设置完后发现其依然是父节点图标,后来发现是虽然代码改了设置,但并未保存到数据库。 2.递归删除父节点及其子节点时,发现老是删不...

    做淘淘商城项目,树形结构递归删除父节点时,出现两个bug
    如图
    这里写图片描述
    1.当删除子节点后其父节点没有其他子节点时,应将其父节点标志设置为false,但是设置完后发现其依然是父节点图标,后来发现是虽然代码改了设置,但并未保存到数据库。
    2.递归删除父节点及其子节点时,发现老是删不干净,后来发现代码错误,原来是

    if(children.size() > 0){
                for (TbContentCategory tbContentCategory : children) {
                    deleteContentCategoryById(tbContentCategory.getId());
                }
    }else{
    ...
    }

    结构,递归删除其子节点后,无须else,都要继续删除其父节点并判断是否设置父节点图标改变。
    正确的是

    public TaotaoResult deleteContentCategoryById(long id) {
            TbContentCategory contentCategory = contentCategoryMapper.selectByPrimaryKey(id);
            TbContentCategoryExample example = new TbContentCategoryExample();
            Criteria criteria = example.createCriteria();
            criteria.andParentIdEqualTo(id);
            List<TbContentCategory> children = new ArrayList<>();
            children = contentCategoryMapper.selectByExample(example);
            if(children.size() > 0){
                for (TbContentCategory tbContentCategory : children) {
                    deleteContentCategoryById(tbContentCategory.getId());
                }
            }
    
            contentCategoryMapper.deleteByPrimaryKey(id);
    
            TbContentCategory parent = contentCategoryMapper.selectByPrimaryKey(contentCategory.getParentId());
            TbContentCategoryExample example2 = new TbContentCategoryExample();
            Criteria criteria2 = example2.createCriteria();
            criteria2.andParentIdEqualTo(parent.getId());
            List<TbContentCategory> list = new ArrayList<>();
            list = contentCategoryMapper.selectByExample(example2);
            if(list.size() == 0){
                parent.setIsParent(false);
                contentCategoryMapper.updateByPrimaryKey(parent);
            }
            return TaotaoResult.ok(contentCategory);
        }
    展开全文
  • 上篇删除最大值节点的操作,其实删除的节点要么没有左右子节点,要么只可能有左节点, 同样,删除最小值节点的操作,其实删除的节点要么没有左右子节点,要么只可能有右节点 (1)删除只有左节点的节点,如删除...
  • 删除树结构的节点,需考虑两件事: 1.要删除的节点若包含子节点,则需删除...要遍历结构中的一个节点及其子节点,采用递归会比较方便,首先需要一个方法,来将这两件事包含在一起,于是要构建一个方法delClasse
  • 子节点修改删除后,子节点视图不刷新 初次解决办法: export default { inject: ['sizeReload'], } 子节点变化后执行: this.sizeReload() 子节点变化后,进行页面的刷新操作,但是刷新后,节点会自动折叠,且...
  • 1. 红黑删除操作过程分析 1. 首先看一下普通搜索二叉树的删除操作,普通搜索二叉树删除结点找替代结点有3种情情景: 情景1:删除结点无结点,直接删除 情景2:删除结点只有一个结点 情景3:删除...
  • 1.先找出该节点的直接后继,因为该节点同时有左右两枝,所以直接后继一定是它的右子树的最小(最左)节点。并且因为直接后继是一个子树中的最小节点,所以直接后继没有左子树。 2.将该节点的值和直接后继的值交换 ...
  • /** * 二叉搜索删除一般分为三种情况; * 1. 要删除节点本身是叶子结点 ->... 找到该节点A 的后继节点(比该节点大的最小节点,也就是右子树的最左叶子结点)B 然后用B替换A 最后再右子树删除B(又可以...
  • dtree 删除子节点

    千次阅读 2013-05-30 18:29:16
    dtree是一个不错的树结构插件,可惜不支持节点删除功能,在晚上找了半天也没有看到合适的处理方法,于是自己动手丰衣足食吧!在这里和大家分享一下! 1.用firefox的firebug查看树结构可以发现 APK
  • 1.关键点是设置一个存储节点的仓库,且用new Map存储 2.在表格数据实时更新后引用maps的数据,动态更新子节点的内容 ...3.如果是删除操作的话,这里需要加一段代码,先清空掉对应子节点的父节点下的数据 ...
  • 根节点删除: ... 子节点删除 2.1 子节点没有左右孩子 2.2 子节点只有左孩子 2.3 子节点只有右孩子 2.4 子节点有左右孩子 现在配合图例来分别描述这六种情况. 创建后的BST结构如下:...
  • Java8新特性Stream——递归遍历结构, 递归删除节点及其子节点 日常开发中,偶尔会碰需要结构数据,层级菜单显示,或者是根据指定id删除该id和其所有的子节点,下面开始讲如何使用Java8新特性Stream来完成这两个...
  • 二叉排序树删除节点

    千次阅读 2019-08-06 17:11:17
    二叉排序,是非常特殊的一种,具体定义见任何一本数据结构书籍。 其删除一个节点需要考虑...3.如果待删除节点左子树存在右子树不存在,或者左子树不存在右子树存在。直接将其子树中存在的一边候补上来即可。...
  • 这里的删除节点,如果是含有左右子节点的节点删除,会删除整个节点,到后期的知识会只删除该节点,而添加子节点。 如:删除3节点,这里会删除3、5、4整个右子节点树;后面的知识会只删除3节点。 public class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,321
精华内容 528
关键字:

树结构删除子节点