精华内容
下载资源
问答
  • 构建一个排序二叉树,然后删除其中一个结点,使剩下的结点仍构成一个排序二叉树
  • 二叉树删除能够算是二叉树最为复杂的操作,删除的时候要考虑到非常多种情况:1.被删除节点是叶子...被删除的有两孩子节点所以在删除的时候。这4种情况都必须考虑进去,而且这4中情况之下,还会有细的划分。...
     二叉树的删除能够算是二叉树最为复杂的操作,删除的时候要考虑到非常多种情况:
    1.被删除的节点是叶子节点
    2.被删除的节点仅仅有左孩子节点
    3.被删除的节点仅仅有右孩子节点
    4.被删除的有两个孩子节点
     
    所以在删除的时候。这4种情况都必须考虑进去,而且这4中情况之下,还会有细的划分。以下就细说怎么删除。
     
    在二叉树中想要删除一个节点,首先须要找到这个节点,因为二叉树在插入节点的时候会遵循一个原则。就是利用节点的值来推断
    节点将被插入的位置(或者给节点加一个key,用key来推断)。从根节点開始往下走。比当前节点小(或等于)的会被插入到
    当前节点的左边,比当前节点大的会被插入到当前节点的右边。所以。依据依据二叉树的插入规则来找出即将被删除的节点。

    代码例如以下; 

    //保存当前节点
    		Node parent=root;//保存当前节点父节点
    		boolean isLeft=true;//记录是否是左几点
    		//定位到将被删除的节点 
    		while(key!=curr.key){
    			if(key<=curr.key){
    				isLeft=true;//经过左节点
    				if(curr.left!=null){
    					parent=curr;
    					curr=curr.left;
    				}
    			}else{
    				isLeft=false;//经过右节点
    				if(curr.right!=null){
    					parent=curr;
    					curr=curr.right;
    				}
    			}
    			if(curr==null){
    				return false;
    			}
    }


      在这断代码中,首先定义了两个引用,一个用来代表当前节点,一个用来代表当前节点的父节点,然后进入一个while循环,
    循环里。首先会依据key的比較来决定该往左走还是往右走。假设往左走,就说明当前节点是它父节点的左孩子了。然后把
    ifLeft设置为true,假设往右走。同理就把isLeft设置为false(isLeft在后面会被用到)。如今,往下走得方向
    已经确定了,然后该就推断所经过的节点(即当前节点)是否为空,假设该节点的左右都为空,就说明你要删的节点没有找到。程序
    将会返回false。假设假设当前节点左孩子不为空,就把当前节点等于它的左孩子,相当于又往下走了一步。

    正个寻找的过程。就是
    不停的依据值推断,不停的往下走。直到满足条件。循环停止。这时。当前节点就保存的是即将被删除节点的引用,而且还知道被删除的
    父节点是谁,被删除节点是它父节点的哪边的孩纸都知道。
    找到了被删除的节点。以下就来看。要怎么删除它。
    1.假设被删除的节点是叶子节点,用代码表示就是

    if(curr.left==null&&curr.right==null){
    			if(curr==root){
    				root=null;
    			}else if(isLeft){
    				parent.left=null;
    			}else{
    				parent.right=null;
    			}
    		}


    能够看出。情况又被细分了三种,当被删除节点即是叶子节点又是根节点,这是树中就仅仅有一个根节点了,就直接删除
    以下两种是推断的是,当前被删除节点是其父节点哪边的节点。

    2.被删除的节点仅仅有左孩子节点
    if(curr.right==null){
    			if(curr==root){
    				root=root.left;
    			}else if(isLeft){
    				parent.left=curr.left;
    			}else{
    				parent.right=curr.left;
    			}
    		}
    当被删除的节点仅仅有一个孩子时。就仅仅须要用它的孩子节点,把它自己给替换下去。

    详细的还是跟上面一样,须要分三种情况
    来考虑,假设是根节点,就直接把根节点指向根节点的左孩子,这样一来,原来的根节点就无法訪问到,会被虚拟机自己主动回收掉。
    同理以下也一样。

     
    3.被删除的节点仅仅有右孩子节点,这样的情况跟另外一种情况相似
      

    if(curr.left==null){
    			if(curr==root){
    				root=root.right;
    			}else if(isLeft){
    				parent.left=curr.right;
    			}else{
    				parent.right=curr.right;
    			}
    		}


     
    4.被删除的有两个孩子节点,这样的情况最复杂,因为要考虑到删除之后顺序不能乱。
    所以这样的类型的节点要删除。假设直接删,真个树的大小顺序就乱了,所以须要考虑,在树中找到一个合适的节点来把这个节点
    给替换掉。用这样的方法来保持整个数的稳定。

    所以又一个问题又来了了。该找哪个节点来替换它?结论是,须要在树中找出全部比
    被删除节点的值大的全部数。并在这些数中找出一个最小的数来。听起来非常拗,假设把它用图形来描写叙述的话,就是,从被删除的节点出发
    经过它的右节点。然后右节点最左边的叶子节点就是我们要找的,它有一个专业名词叫中序后继节点。

    以下专门来写一个方法来找它:
      
       

     public Node getSuccessor(Node delNode){  //參数为被删除的节点
    			//定义一个当前节点的引用。直接让往下走一步,走到被删除节点的右节点
    			Node curr=delNode.right; 
    			Node successor=curr;  //用来指向中级兴许节点
    			Node sucParent=null; //用来指向中级兴许节点的父节点
    			while(curr!=null){  
    				sucParent=successor;
    				successor=curr;
    				curr=curr.left;
    			}
    			//循环停止,中级兴许节点被找出
    			if(successor!=delNode.right){
    				//将后继节点的子节点(仅仅可能有右节点)替补到后继节点的位置上
    				sucParent.left=successor.right;
    				//将被删除的右孩子连接到后继节点的右节点上
    				successor.right=delNode.right;
    				//将被删除的左孩子连接到后继节点的右节点上(就是用后继节点替换掉被删除的节点)
    			}
    			return successor;
    		}



    因为过程比較复杂。这里用图来表示



    删除节点的完毕代码:

    /**
    	 * 删除节点
    	 * @param key
    	 */
    	public boolean delete(int key){
    		Node curr=root;//保存当前节点
    		Node parent=root;//保存当前节点父节点
    		boolean isLeft=true;//记录是否是左几点
    		//定位到将被删除的节点 
    		while(key!=curr.key){
    			if(key<=curr.key){
    				isLeft=true;//经过左节点
    				if(curr.left!=null){
    					parent=curr;
    					curr=curr.left;
    				}
    			}else{
    				isLeft=false;//经过右节点
    				if(curr.right!=null){
    					parent=curr;
    					curr=curr.right;
    				}
    			}
    			if(curr==null){
    				return false;
    			}
    		}
    		//假设被删除节点是叶子节点
    		if(curr.left==null&&curr.right==null){
    			if(curr==root){
    				root=null;
    			}else if(isLeft){
    				parent.left=null;
    			}else{
    				parent.right=null;
    			}
    		//假设被删除节点仅仅有左节点
    		}else if(curr.right==null){
    			if(curr==root){
    				root=root.left;
    			}else if(isLeft){
    				parent.left=curr.left;
    			}else{
    				parent.right=curr.left;
    			}
    		//假设被删除节点仅仅有右节点
    		}else if(curr.left==null){
    			if(curr==root){
    				root=root.right;
    			}else if(isLeft){
    				parent.left=curr.right;
    			}else{
    				parent.right=curr.right;
    			}
    		}else{
    			Node successor=getSuccessor(curr);
    			//将后继节点与被删除的父节点进行连接,完毕整个替换过程
    			if(curr==root){
    				root=successor;
    			}else if(curr==parent.left){
    				parent.left=successor;
    			}else{
    				parent.right=successor;
    			}
    			successor.left=curr.left;
    		}
    		return true;
    		
    	}
    	
    	public Node getSuccessor(Node delNode){
    		Node curr=delNode.right;
    		Node successor=curr;
    		Node sucParent=null;
    		while(curr!=null){
    			sucParent=successor;
    			successor=curr;
    			curr=curr.left;
    		}
    		if(successor!=delNode.right){
    			//将后继节点的子节点(仅仅可能有右节点)替补到后继节点的位置上
    			sucParent.left=successor.right;
    			//将被删除的右孩子连接到后继节点的右节点上
    			successor.right=delNode.right;
    			//将被删除的左孩子连接到后继节点的右节点上(就是用后继节点替换掉被删除的节点)
    		}
    		return successor;
    	}


    转载于:https://www.cnblogs.com/xfgnongmin/p/10860492.html

    展开全文
  • forth:如果删除节点又左右孩子,那么可以归并删除节点后的子树:方法有两种种是用删除节点的左子树的最右节点,指向删除节点的右子树,另种是用删除节点的用字数的最左节点指向删除节点的左子树。 Java 实现...

    实现的思想很简单:

    first:找到要删除的节点

    second:如果删除的节点没有右子树那么左子树链到父节点

    third:如果删除的节点没有左子树那么右子树链到父节点

    forth:如果删除的节点又左右孩子,那么可以归并删除节点后的子树:方法有两种一种是用删除节点的左子树的最右节点,指向删除节点的右子树,另一种是用删除节点的用字数的最左节点指向删除节点的左子树。

    Java 实现如下:

    public void deleteByMerging(int el)
    {
    IntBSTNode tmp,node,p=root,prev=null;
    /*find the node to be deleted*/
    while(p!=null&&p.key!=el)
    {
    prev=p;
    if(p.key<el)
    p=p.right;
    else p=p.left;
    }
    /*find end*/


    node=p;
    if(p!=null&&p.key==el)
    {
    if(node.right==null)   //node has no right child then its left child (if any) is attached to 
    node=node.left;   //its parent
       else if(node.left==null)//node has no left child then its right child (if any) is attched to
       node=node.right      //its parent
    else{
    tmp=node.left;    
    while(tmp.right!=null)
    tmp=tmp.right;      //find the rightmost node of the left subtree
    tem.right=node.right;   //establish the link between the rightmost node of the left subtree and the right subtree
    node=node.left;
    }
    if(p==root)
    {
    root=node;
    }
    else if (prev.left==p)
    {
    prev.left=node;
    }
    else prev.right=node
    }
    else if(root!=null)
       {
    System.out.println("the node is not in the tree");
    }
    else System.out.println("The tree is empty");
    }

    展开全文
  • 二叉树删除节点

    2017-11-04 12:53:02
    二叉树删除节点比较麻烦,一般可能会设置一个isdeleted标记删除的节点而不真的删除节点,删除情况有以下几种: 1,删除的节点是根节点 2,删除的节点无子节点 3,删除的节点只有一个节点 4,删除的节点有2个子...

    二叉树删除节点比较麻烦,一般可能会设置一个isdeleted标记删除的节点而不真的删除节点,删除情况有以下几种:

    1,删除的节点是根节点

    2,删除的节点无子节点

    3,删除的节点只有一个子节点

    4,删除的节点有2个子节点。这里面又要判断删除的节点的右子节点有无左子节点,如无,将右子节点替换删除的节点即可;如有,找到最左子节点,去替换要删除的节点,还要注意最左子节点可能也有右子节点,这个节点也要接到最左子节点的父节点上去

    以下是代码:

    //删除根节点代码有误,在其他判断里加上一个判断是否是根的条件即可

    boolean delete(int key){
          if(!isEmpty()){
              Node current=root;
              Node temp=root;
                  while(current.data!=key){
                       temp=current;//保存要删除节点的父节点
                      if(key<current.data)
                          current=current.left;
                      else current=current.right;
                      if(current==null)
                          return false;
                      
                      }
                  if(current==root)//根节点,有误,在其他处判断
                      root=null;
                  else if(current.left==null&&current.right==null){//无子节点
                      if(current.data<temp.data)
                          temp.left=null;
                      else temp.right=null;
                  }
                  else if(current.left==null&&current.right!=null){//右子节点
                      if(current.data<temp.data)
                          temp.left=current.right;
                      else temp.right=current.right;
                  }
                  else if(current.left!=null&&current.right==null){//左子节点
                      if(current.data<temp.data)
                          temp.left=current.left;
                      else temp.right=current.left;
                  }
                  else{//有2个子节点
                      if(current.right.left==null){//要删除的节点的右子节点没有左子节点
                          current.right.left=current.left;
                          if(current.data<temp.data){
                              temp.left=current.right;
                          }
                          else{
                              temp.right=current.right;
                          }
                          
                      }
                      else{
                          Node t=current.right.left;
                          Node temp1=current.right;
                         while(t.left!=null){
                             t=t.left;
                             temp1=temp1.left;//保留要删除节点的右子节点的最左子节点的父节点
                         }
                         if(t.right==null){//此时t肯定无左子节点
                             t.left=current.left;
                             t.right=current.right;
                             if(current.data<temp.data){
                                 temp.left=t;
                             }
                             else{
                                 temp.right=t;
                             }
                            
                            temp1.left=null;
                            
                         }
                         else{
                             Node temp2=t.right;
                             t.left=current.left;
                             t.right=current.right;
                             if(current.data<temp.data)
                                 temp.left=t;
                             else temp.right=t;
                             temp1.left=temp2;
                         }
                      }
                          
                  }
                  return true;
                  }
          else return false;
              }  
    这里面(可能会)存在一个问题,是一个顺序问题,比如你如果先把最左子节点接到要删除的节点的父节点上去,然后再把要删除节点的左子节点接到替换后的最左子节点上去,以及之后的一些接上节点操作,要删除节点的父节点一旦不再指向它,那么它的和它的子节点可能当垃圾回收掉,虽然引用不指向它只有片刻时间,我也不知道是不是存在被回收的可能性,但是最好顺序要做好。代码中顺序应该是没有逻辑问题的。

    展开全文
  • 二叉树的构建,先序中序后序的遍历,查找一个数据是否在二叉树中,删除一个节点 package tree; /** * Created by Administrator on 2015/10/8 0008. */ public class BinaryTree { BinaryTree root; Binary...

    二叉树的构建,先序中序后序的遍历,查找一个数据是否在二叉树中,删除一个节点

    package tree;
    
    /**
     * Created by Administrator on 2015/10/8 0008.
     */
    public class BinaryTree {
        BinaryTree root;
        BinaryTree lchild;
        BinaryTree rchild;
        BinaryTree parent;
        int value;
        BinaryTree(int value){
            this.value=value;
            root=null;
            lchild=null;
            rchild=null;
            parent=null;
            //insert(root,value);
        }
        BinaryTree(){}
    
        //插入数据构造树
        public static void insert(BinaryTree root, int value){
            if(root==null) {
                root.value = value;
                root.parent=null;
            }
            else{
                if(value<root.value){
                    if(root.lchild==null) {
                        root.lchild = new BinaryTree(value);
                        root.lchild.parent=root;
                    }
                    else
                        insert(root.lchild,value);
                }
                else {
                    if (root.rchild == null) {
                        root.rchild = new BinaryTree(value);
                        root.rchild.parent=root;
                    }
                    else
                        insert(root.rchild, value);
                }
            }
        }
    
        //三种遍历:先序,中序,后序
        public static void preTraval(BinaryTree root){
            if(root==null)
                return;
            else {
                System.out.println("root->value" + root.value);
                preTraval(root.lchild);
                preTraval(root.rchild);
            }
        }
    
        public static void centerTraval(BinaryTree root){
            if(root==null)
                return;
            else {
                centerTraval(root.lchild);
                System.out.println("root->value" + root.value);
                centerTraval(root.rchild);
            }
        }
    
        public static void afterTraval(BinaryTree root){
            if(root==null)
                return;
            else {
                afterTraval(root.lchild);
                afterTraval(root.rchild);
                System.out.println("root->value" + root.value);
            }
        }
    
        //查找树中是否有这个值
        public static boolean find(BinaryTree root,int value){
            if(root==null)
                return false;
            /*else {
                if (value ==root.value)
                    return true;
                else if(value<root.value) {
                    System.out.println(root.lchild.value);
                    //root=root.lchild;
                    find(root.lchild, value);
                }
                else{
                    System.out.println(root.rchild.value);
                    find(root.rchild, value);
                }
                return false;
            }*/
            else{
                BinaryTree bt=root;
                while(bt!=null){
                    if(value==bt.value)
                        return true;
                    else if(value<bt.value)
                        bt=bt.lchild;
                    else
                        bt=bt.rchild;
                }
                return false;
            }
        }
    
        //删除一个节点
        public static void delete(BinaryTree root,BinaryTree p){
            if(root==null||p==null)
                return;
            else {
                //p是根节点
                if(p.parent==null)
                    root=null;
                else {
                    //p是叶子节点
                    if (p.lchild == null && p.rchild == null) {
                        if (p == p.parent.lchild)
                            p.parent.lchild = null;
                        else if (p == p.parent.rchild)
                            p.parent.rchild = null;
                    }
                    //p只有左孩子
                    else if (p.lchild!=null&&p.rchild==null){
                        if(p==root)
                            root=p.lchild;
                        else if(p==p.parent.lchild){
                            p.parent.lchild=p.lchild;
                            p.lchild.parent=p.parent;
                        }
                        else if(p==p.parent.rchild){
                            p.parent.rchild=p.lchild;
                            p.lchild.parent=p.parent;
                        }
                    }
                    //p只有右孩子
                    else if (p.lchild==null&&p.rchild!=null){
                        if(p==root)
                            root=p.rchild;
                        else if(p==p.parent.lchild){
                            p.parent.lchild=p.rchild;
                            p.rchild.parent=p.parent;
                        }
                        else if(p==p.parent.rchild){
                            p.parent.rchild=p.rchild;
                            p.rchild.parent=p.parent;
                        }
                    }
                    //p既有左孩子又有右孩子
                    else{
                        //让左孩子代替p
                        //如果p的左孩子无右孩子,则直接替代
                        if(p.lchild.rchild==null){
                            if(p.parent==null)
                                root=p.lchild;
                            else if(p==p.parent.lchild){
                                p.parent.lchild=p.lchild;
                                p.lchild.parent=p.parent;
                            }
                            else if(p==p.parent.rchild){
                                p.parent.rchild=p.lchild;
                                p.lchild.parent=p.parent;
                            }
                        }
                        //如果有右孩子,将左孩子的右孩子放到p的有孩子中
                        else if(p.lchild.rchild!=null){
                            BinaryTree troot=new BinaryTree();
                            troot=p.lchild.rchild;
                            /*while(p.lchild!=null||p.rchild!=null){
                                troot.lchild=p
                            }*/
                            insert(p.rchild,troot.value);
                        }
    
                    }
                }
            }
        }
        public static void delete(BinaryTree root,int value){
            if(find(root,value)){
                BinaryTree p=new BinaryTree(value);
                delete(root,p);
            }
        }
    
        public static void main(String[] args) {
            int a[]={5,3,7,9,2,8};
            BinaryTree root=new BinaryTree(a[0]);
            for(int i=1;i<a.length;i++)
                insert(root,a[i]);
            /*preTraval(root);
            System.out.printf("\n");
            centerTraval(root);
            System.out.printf("\n");
            afterTraval(root);*/
    
            //System.out.println(find(root,9));
    
            preTraval(root);
            delete(root, 2);
            System.out.printf("\n");
            preTraval(root);
    
        }
    }
    

    在main函数中有测试用例,大家可以粘到本地进行测试


    展开全文
  • 二叉查找树重要性质: (1)若左子树不空,则左子树上所有结点的值均小于它的根结点的值; (2)若右子树不空,则右子树上所有结点的值均大于它的根结点的值;... 现有,如下棵二叉查找树。 ...
  • 二叉树删除节点

    2020-09-09 10:11:30
    首先考虑如果树是空树root,如果只有一个root结点,则等价将二叉树置空. 1).因为我们的二叉树是单向的,所以我们是判断当前结点的子结点是否需要删除结点,而不能去判断当前这个结点是不是需要删除结点。 2)如果当前...
  • 我们首先看一下删除一个不是根节点的节点牵涉到几个节点: 删除E后 现在需要删掉E 需要 E的父节点 B ,以A为根节点的最大节点(上一篇讲过获取B节点) A,E的左孩子 F,E的右孩子   思路如下...
  • 二叉树删除节点

    2020-09-14 13:28:11
    首先考虑如果这个树是空树的话,只有一个root节点,是没有办法删除的 因为二叉树是单向的,所以我们只能判断当前节点的子节点是否需要被删除 如果当前节点的左子节点不为空,并且左子节点就是要删除节点,那么...
  • Java-二叉树删除节点

    2020-10-21 22:20:22
    考虑如果树是空树root,如果只有一个root节点,则等价二叉树置空 然后进行下列操作: 1.因为我们的二叉树是单向的,所以我们判断当前节点的子节点是不是需要删除节点,而不能判断当前节点是不是需要删除节点 2....
  • #include #include using namespace std; template class BinaryTreeNode{ public: ... cout 删除叶子结点后的二叉树先序序列为:" ; t->deletelea(root,pre); t->preOrder(root); return 0; }  
  • 二叉树删除节点2

    2019-03-16 12:02:55
    第二张情况: ... //只有两个节点二叉树 删除了根节点 那么原来的根节点右孩子 //就是新的根节点 if(cur == root){ root = cur.rc; } //就是左孩子就是要寻找的节点 else if(islc){ pre...
  • ** 二叉树相关代码,只是基于一个大示例小步迭代,层层递进的增加功能代码. ** 这里只需要关注deleteNode()方法即可。 ** 全贴出来,只是便于测试而已。 ** 这里的删除节点,是限定条件的实现。 ** 条件: 1.如果...
  • 删除二叉树节点

    2020-01-28 23:39:36
    :删除节点 删除节点比较复杂 步骤: 1.找到需要被删除节点 2.判断该节点的类型 2.1该节点是叶子节点,直接修改父节点的引用值为null即可 2.2该节点个子节点,修改父节点得引用,将该节点的父节点的应用指向该...
  • 9.2 二叉树(删除节点)

    2020-08-14 21:26:21
    考虑如果树是空树root,如果只有一个root结点,则等价将二叉树置空 然后进行下面步骤 1.因为我们的二叉树是单向的,所以我们是判断当前结点的子结点是否需要删除结点,而不能去判断当前这个结点是不是需要删除结点. 2...
  • 一棵二叉树,每一个节点都有左子树和右子树,二叉树的操作都可以递归的调用子树来完成。在C中有指针的概念,子树用指针实现,函数用指针作为参数。但是,Python采用对象引用,对空对象赋值,只在函数作用范围内有效...
  • 删除二叉树节点

    2019-08-24 00:15:57
    删除任意一节点例子: 删除最小值,首先要找到最小值 Node * getMin(Node* node) { if(node->left ==NULL) return node; return getMin(node->left) } Node* removeMin(Node* node) { if(node-&...
  • 简述: ...1. 是棵二叉搜索树(故而每个节点是惟一的, 如果出现重复数字会破坏平衡树的算法) 2. 每个节点左右子树的高度之差(平衡因子)相差最多为1 实现: 为了使所得的二叉树为平衡...
  • Day60:删除二叉搜索树的某个节点1 题目给定一个二叉搜索树的根节点 root 和一个值 key,删除二叉搜索树中的 key 对应的节点,并保证二叉搜索树的性质不变。返回二叉搜索树(有可能被更新)的根节点的引用。一般来说,...
  • 二叉树节点删除

    千次阅读 2016-09-25 11:18:09
    1.被删除的节点是叶子节点,这时候只要把这个节点删除,再把指向这个节点的父节点指针置为空就行 2.被删除的节点有左子树,或者有右子树,而且只有其中一个,那么只要把当前删除节点的父节点指向
  • 在上一小节用java实现二分搜索树以及它的三种遍历方式中我介绍的如何构建一个二叉树,这一小节我来继续如何介绍删除二叉树中的节点
  • 这里的删除节点,如果是含有左右子节点节点删除,会删除整个节点树,到后期的知识会只删除节点,而添加子节点。 如:删除3节点,这里会删除3、5、4整个右子节点树;... //创建一个二叉树 Bi...
  • 平衡二叉树删除某个节点的方法

    千次阅读 2013-09-18 10:29:57
    如果节点Z仅有一个孩子,那么将Z节点的父节点中指向Z的指针指向Z仅有的孩子,然后删除节点Z。如果节点Z有两个非空的子节点,那么找到节点Z的中序后继节点Y(即右子树的最左节点),将节点Y的Key值覆盖节点Z的Key值,...
  • 2.后继有右 就是该节点只有一个节点(可以是左孩子 也可以是右孩子) 3.后继有俩 就是该节点有左右孩子 情况1: 删除了该节点 则该节点的状态为空了 一个二叉树已经是有了大小顺序 设置要删除的节点的值为key 如果...
  • 简述: 实现AVL 树,主要是两个功能 : 插入某节点和删除某节点 AVL Tree的定义, 1. 是一棵二叉搜索树(故而每个节点是惟一的, ...首先在BSTNode中加了一个计算节点高度的方法getHeight(), 当两个节点高度相

空空如也

空空如也

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

二叉树删除一个节点