精华内容
下载资源
问答
  • 二叉树删除叶子结点

    2021-09-28 16:20:12
    王道论坛p196页归纳总结 void BST_Delete(BiTree bt){ if(bt){ BiTree p=bt; if(p->lChild==NULL&&p->rChild==NULL){ free(p); return; } if(p->lChild!...lChild==NULL&a

    王道论坛p196页归纳总结

    void BST_Delete(BiTree bt){
        if(bt){
            BiTree p=bt;
            if(p->lChild==NULL&&p->rChild==NULL){
                free(p);
                return;
            }
            if(p->lChild!=NULL&&p->lChild->lChild==NULL&&p->lChild->rChild==NULL){
                free(p->lChild);
                p->lChild=NULL;
            }
            if(p->rChild!=NULL&&p->rChild->lChild==NULL&&p->rChild->rChild==NULL){
                free(p->rChild);
                p->rChild=NULL;
            }
            BST_Delete(bt->lChild);
            BST_Delete(bt->rChild);
        }
    }
    
    
    展开全文
  • 第一种删除叶子节点() 思路: 1.找到要删除的叶子 2.找到叶子的父节点parent 3.判断叶子是parent的左子节点还是右子节点4根据前面的情况对应删除 左子节点 parent.left=null 右子节点 parent.lright=null 第二种...

    笔记示意图

    第一种删除叶子节点()

    思路:
    1.找到要删除的叶子
    2.找到叶子的父节点parent
    3.判断叶子是parent的左子节点还是右子节点4根据前面的情况对应删除
    左子节点 parent.left=null
    右子节点 parent.lright=null

    第二种情况:
    1.找到要删除的节点targetnode
    2.找到叶子的父节点parent
    3.确定targetnode的子节点是左子节点还是右子节点
    (4)确定target是parent的左子节点还是右子节点
    (5)如果targetnode有左子节点
    5.1如果targetnode是parents的左子节点
    Parent,left=targetnode.left
    5.2如果targetnode是parents的右子节点
    Parent.right=targetnode.left
    (6)如果targetnode有右子节点
    如果targetnode是parent的左子节点
    Parent,left=targetnode.right
    如果targetnode是parent的右子节点
    Parent,right=targetnode.right
    情况三 删除有两颗子树的节点

    思路
    (1)找到要删除的节点targetnode
    2.找到叶子的父节点parent
    (3)从targetnode的右子树找到最小的节点
    (4)用一个临时变量,将最小节点的值保存在tamp中
    (5)删除该最小节点
    (6)targetnode.value=temp
    本次新增了search和searchparent和delNode方法
    注意:只实现了第一种情况的删除

    public class BST {
        public static void main(String[] args) {
               int[]arr={7,3,10,12,5,1,9,2};
               BinarySortTree binarySortTree=new BinarySortTree();
            for (int i = 0; i < arr.length; i++) {
                binarySortTree.add(new Node(arr[i]));
            }
            System.out.println("中序遍历");
            binarySortTree.infixOrder();
            //删除节点
            System.out.println("删除后");
            binarySortTree.delNode(5);
            binarySortTree.infixOrder();
        }
    }
    class  BinarySortTree{
        private Node 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 delNode(int value) {
            if (root == null) {
                return;
            } else {
                //1.先找到要删除的节点
                Node targetNode = search(value);
                //如果没有找到要删除的节点
                if (targetNode == null) {
                    return;
                }
                //如果我们发现当前这颗二叉排序树只有一个节点
                if (root.left == null && root.right == null) {
                    root = null;
                    return;
                }
    
                //找到targetnode的父节点
                Node parent = searchParent(value);
                //如果要删除的是叶子节点
                if (targetNode.left == null && targetNode.right == null) {
                    //判断targetnode是左子节点还是右子节点
                    if (parent.left != null && parent.left.value == value) {
                        parent.left = null;
                    } else if (parent.right != null && parent.right.value == value) {
                        parent.right = null;
                    }
                }
            }
        }
        public  void add(Node node){
            if (root==null){
                root=node;//如果树为空,让root指向node
    
            }else  {
                root.add(node);
            }
        }
        public  void infixOrder(){
            if (root!=null){
                root.infixOrder();
            }else {
                System.out.println("二叉排序树为空不能遍历");
            }
        }
    }
    class Node{
        int value;
        Node left;
        Node right;
        //查找要删除的节点
        //value希望删除结点的值
        public Node search(int value){
            if(value==this.value){
                return  this;
            }else if(value<this.value){
                //向左子树递归查找
                if (this.left==null){
                    return null;
                }
                return  this.left.search(value);
            }else {
                //查找结点大于当前节点
                if (this.right==null){
                    return null;
                }
                return  this.right.search(value);
            }
        }
        //查找要删除节点的父节点
    
        /**
         *
         * @param value 要找的节点的值
         * @return 要删除的节点的父节点,如果没有返回null
         */
        public  Node searchParent(int value){
              if((this.left!=null&&this.left.value==value)||(this.right!=null&&this.right.value==value)){
                  return this;
              }else {
                  //如果查找节点的值小于当前节点的值,并且当前节点的左子节点不为空
    
                  if(value<this.value&&this.left!=null){
                      return this.left.searchParent(value);
                  }else if(value>=this.value&&this.right!=null) {
                      //注意相等情况
                      //右递归找
                      return this.right.searchParent(value);
    
                  }else {
                      //无父结点
                      return null;
                  }
              }
        }
    
        public Node(int value) {
            this.value = value;
        }
        //递归添加节点,满足二叉排序树的要求
        public void add(Node node){
            if (node==null){
                return;
            }
            //判断传入节点的值和子树根节点的值
            if(node.value<this.value){
                //如果当前节点左子节点为空
                if(this.left==null){
                   this.left=node;
                }else {
                    //递归向左子树添加
                     this.left.add(node);
                }
            }else {//节点大于当前节点
                 if(this.right==null){
                    this.right=node;
                }else {
                    //递归向右子树添加
                    this.right.add(node);
            }
        }
    }
    //中序遍历
        public void infixOrder(){
            if (this.left!=null){
                this.left.infixOrder();
            }
            System.out.println(this.value);
            if (this.right!=null){
                this.right.infixOrder();
            }
        }
    }
    
    展开全文
  • 删除二叉树所有叶子节点

    千次阅读 2020-05-02 19:16:44
    //删除二叉树中的所有叶子节点 void DeleteLev(BiTree T,BiTree f,bool flag){ if(T){//T is not NULL if(T->l){ DeleteLev(T->l,T,true); } if(T->r){ DeleteLev(...
    //删除二叉树中的所有叶子节点
    void DeleteLev(BiTree T,BiTree f,bool flag){
        if(T){//T is not NULL
            if(T->l){
                DeleteLev(T->l,T,true);
            }
            if(T->r){
                DeleteLev(T->r,T,false);
            }else{//T is a level node
                free(T);
                if(f){// T is not root
                    if(flag)f->l = NULL;
                    else f->r = NULL;
                }
                
            }
        }
    }
    
    void main(){
        Init(T);
        DeleteLev(T,NULL,true);
    }
    
    展开全文
  • void Del(BitNode *&p){ if(pnull)return; else if(p->lchildnull&&p->rchild==null){ free(p); p=null; } else{ Del(p->lchild); Del(p->rchild); ...}

    void Del(BitNode *&p){
    if(pnull)return;
    else if(p->lchild
    null&&p->rchild==null){
    free(p);
    p=null;
    }
    else{
    Del(p->lchild);
    Del(p->rchild);
    }
    }

    展开全文
  • 递归删除所有叶子节点

    千次阅读 2016-11-27 21:40:04
    void BiTree::deleteLeaves(BiTreeNode *root) { if (root == NULL) return;... //表示是根节点(或者出错,跑到叶子节点了,这种情况应该不会),不删除 if (root->left) //当前节点有左子树 { if (root->left->left ||
  • 2-3树 叶子节点删除

    2020-04-18 21:10:35
    本文不再阐述关于2-3树的定义、节点的插入以及将删除的非叶子节点转换为叶子节点的方法 注意: 本文仅对2-3树 叶子节点删除操作 进行分类与讨论 定义: 2-节点: 如果某个节点包含1个权值, 那么我们称之为2-节点, ...
  • 给你一棵以root为根的二叉树和一个整数target,请你删除所有值为target 的叶子节点 。 注意,一旦删除值为target的叶子节点,它的父节点就可能变成叶子节点;如果新叶子节点的值恰好也是target ,那么这个节点也...
  • 注意,一旦删除值为 target 的叶子节点,它的父节点就可能变成叶子节点;如果新叶子节点的值恰好也是 target ,那么这个节点也应该被删除。 也就是说,你需要重复此过程直到不能继续删除。 审题: 由于删除的是叶子...
  • 这里面有个特殊情况,就是查找...它也是个叶子节点。那么直接 null,而且这种情况必须先判断。否则后序会报错 public void del(int value) { if (root == null) { return; } Nod search = root.search(value); ...
  • BinaryTreeNode removeleaf(BinaryTreeNode root){ if(root == null){ return null; } if(root.getLeft() == null && root.getRight() == null){ return null; ... root.setLeft(root.getLeft());...
  • 给你一棵以 root 为根的二叉树和一个整数 target ,请你删除所有值为 target 的 叶子节点 。 注意,一旦删除值为 target 的叶子节点,它的父节点就可能变成叶子节点;如果新叶子节点的值恰好也是 target ,那么这个...
  • 依次从左到右,每次收集并删除所有的叶子节点 重复如上过程直到整棵树为空 示例: 输入: [1,2,3,4,5] 输出: [[4,5,3],[2],[1]] 解释: 删除叶子节点 [4,5,3] ,得到如下树结构: 1 / 2 现在删去叶子节点 [2...
  • 寻找叶子到根的路径 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #define OK 1 #define TRUE 1 #define FALSE 0 #define ERROR 0 typedef struct Node{ ...
  • 二叉树叶子结点删除 之前我认为的是,只要free()掉叶子结点就可以了,但是为了避免野指针的出现,我们还需要将指向叶子结点的双亲的左右指针置为NULL! 代码 void Del_0(BiTree T) //删除叶子结点 { BiTNode *p =...
  • 一棵树的根结点到每个叶子结点之间经过的结点序列叫做叶子结点的路径,与图中两个结点的路径不同,叶子结点的路径有且只有一条。本博客主要讨论用程序实现打印二叉树中叶子结点路径的问题。 基本方法 仔细观察一棵...
  • 题目:原题链接(中等) 标签:树、二叉树、深度优先搜索 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) O(N)O(N)O(N) O(N)O(N)O(N) 68ms (58.44%) Ans 2 (Python) ... TreeNode:
  • 4/11 10:20 更新了一些算法解释 4/18 17:17 更新了生成子树的方法,更加灵活了 先贴代码吧 import java.util.*; /** * @Author xjd * @Date 2019/4/3 10:30 ... * 传入的节点结构必须继承本工具...
  • 因为工作需要,所以自己写了一个简单的删除节点的操作,同时,注意,如果使用加强for循环,就不能用remove()方法,因为,加强的for循环是使用的迭代器,而迭代器在做remove()的时候会抛异常。
  • 下面小编就为大家带来一篇使用递归删除树形结构的所有子节点(java和mysql实现)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 内容预览 零、读前说明 一、求二叉树的叶子节点个数 二、求二叉树的深度/高度 三、拷贝二叉树 四、测试案例 零、读前说明 本文中所有设计的代码均通过测试,并且在功能性方面均实现应有的功能。 设计的代码并非全部...
  • 1325. 删除给定值的叶子节点 原始题目链接:https://leetcode-cn.com/problems/delete-leaves-with-a-given-value/ 给你一棵以 root 为根的二叉树和一个整数 target ,请你删除所有值为 target 的 叶子节点 。 注意...
  •   2、当前 node 不是叶子节点,对左右子结点分别调用 recur;   3、返回 node 给上一级调用,即告诉上一级,node 不是叶子节点,当前没删除。 3、解题代码 /** * Definition for a binary tree node. * public ...
  • 首先想这个题的普通节点怎么做,首先删除它的子节点的叶子节点,如果返回来时它自己成了叶子节点,则要删除它自己,所以很显然是后序遍历。 然后就是怎么删除自己的问题,要删除自己,就返回null,然后让自己的父...
  • 目录 树的源数据 获取树的深度 提取并统计树所有的节点 提取并统计树的叶子节点 树的源数据 treeData: { "label": "中国", "children": [ { "label": "浙江", .
  • 删除结点:2 6 */ #include <iostream> #include <malloc.h> #include <deque> using namespace std; const int MAXSIZE = 100; typedef char ElemType; typedef struct BiTNode{ ElemType ...
  • } else { // 叶子节点 if (arr[i].path === targetStr) { // 找到合适的立即结束 const lastArr: string[] = []; finArr.map((r) => { lastArr.push(r.name); }); throw lastArr; } else { // 没找到合适的,如果是...
  • 如果是偶数个节点,叶子节点等于总节点除以2, 即 N % 2==0, n = N/2 如果是奇数个叶子节点等于(总节点+1)除以2, 即 N % 2 == 1, n = (N+1)/2 即向上取整。 推导可参考:...
  • 删除二叉树中度为0的结点(即叶子结点)
  • JS 递归树结构数据查找所有叶子节点 export function getAllLeaf (data) { let result = [] function getLeaf (data) { data.forEach(item => { if (!item.children) { result.push(item.path) } ...
  • 求二叉树叶子结点个数

    千次阅读 2018-04-12 15:26:14
    = 0)结点组成的有限集合T,有且仅有一个结点称为根(root),当 n&gt;1时,其余的结点分为m(m &gt; 0)个相互不相交的有限集合T1, T2, ..., Tm。每个集合本身又是棵树,被称作这个根的子树。 树的结构特点: 1.非...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,863
精华内容 31,545
关键字:

删除叶子节点