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

    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;
              }  
    这里面(可能会)存在一个问题,是一个顺序问题,比如你如果先把最左子节点接到要删除的节点的父节点上去,然后再把要删除节点的左子节点接到替换后的最左子节点上去,以及之后的一些接上节点操作,要删除节点的父节点一旦不再指向它,那么它的和它的子节点可能当垃圾回收掉,虽然引用不指向它只有片刻时间,我也不知道是不是存在被回收的可能性,但是最好顺序要做好。代码中顺序应该是没有逻辑问题的。

    展开全文
  • 二叉树删除节点 在自己研究二叉树删除节点时,查网上资料时发现,网上大部分写的都是错的,主要错在当删除节点既存在左子树,又存在右子树时,在中序遍历后获取后继节点后,大部分文章未考虑后继节点存在右子树的...

    二叉树删除节点

    在自己研究二叉树删除节点时,查网上资料时发现,网上大部分写的都是错的,主要错在当删除的节点既存在左子树,又存在右子树时,在中序遍历后获取后继节点后,大部分文章未考虑后继节点存在右子树的情况。

    1.二叉树图

    在这里插入图片描述
    删除的节点有4种情况

    1. 叶子节点
    2. 只存在左节点
    3. 只存在右节点
    4. 既存在左节点,又存在右节点

    以上四种情况分别如下处理:

    1只需要将引用去除就行
    2将删除节点的左子树,挂到父节点上
    3将删除节点的右子树,挂到父节点上
    4中序遍历树,获取删除节点的后继节点,即大于删除节点的最小节点,后继节点可以确定的是肯定不存在左子树,因为后继节点就是删除节点右子树里面最小的节点了,肯定不存在比他还小的节点。但是还是有可能存在右子树的 。处理逻辑就是将后继节点的值覆盖删除节点的值,并将后继节点的右子树挂到后继节点的父节点上。

    下面就是硬干代码了,有个技巧,中序遍历出来的结果正好是升序排列的树,所以在删除后,可以通过打印中序遍历的结果,查看整棵树是不是正确的。

    2.节点数据结构

    public static class Node<T>{
            private T data;
            private Node<T> left;
            private Node<T> right;
            private Node<T> parent;
            public Node(T data) {
                this.data = data;
            }
            public T getData() {
                return data;
            }
            public Node<T> getParent() {
                return parent;
            }
            public void setParent(Node<T> parent) {
                this.parent = parent;
            }
            public void setData(T data) {
                this.data = data;
            }
            public Node<T> getLeft() {
                return left;
            }
            public void setLeft(Node<T> left) {
                this.left = left;
            }
            public Node<T> getRight() {
                return right;
            }
            public void setRight(Node<T> right) {
                this.right = right;
            }
        }
    

    3.先序创建树

    // 创建树
    public static Node<String> createTree(List<String> dataList,Node<String> parent){
            Node<String> root = null;
            if(!dataList.isEmpty()){
                String data = dataList.remove(0);
                if(data!=null){
                    root=new Node<>(data);
                    root.setParent(parent);
                    root.setLeft(createTree(dataList,root));
                    root.setRight(createTree(dataList,root));
                }
            }
    
            return root;
        }
        
        //二叉树初始化
        List<String> strings = new ArrayList<>();
            strings.add("20");
            strings.add("7");
            strings.add("3");
            strings.add("2");
            strings.add(null);
            strings.add(null);
            strings.add("4");
            strings.add(null);
            strings.add(null);
            strings.add("10");
            strings.add("8");
            strings.add(null);
            strings.add("9");
            strings.add(null);
            strings.add(null);
            strings.add("12");
            strings.add(null);
            strings.add(null);
            strings.add("30");
            strings.add("25");
            strings.add(null);
            strings.add("26");
            strings.add(null);
            strings.add(null);
            strings.add("35");
            strings.add(null);
            strings.add(null);
            tree = createTree(strings,null);
            
    

    4.删除操作

    // 删除节点
    public static String deleteNode(Node<String> tree,String value){
    
            //找到指定节点
            Node<String> deleteNode = findNode(tree, value);
            //节点不存在直接返回
            if(deleteNode==null){
                return null;
            }
    		//原值
            String result = deleteNode.getData();
    
            //判断子节点情况
            //及存在左子树又存在右子树
            if(deleteNode.getLeft()!=null && deleteNode.getRight()!=null){
                //对整个树中序遍历,以获取删除节点的后继节点(大于删除节点的最小节点)
                Node<String> afterNode = findAfterNode(tree, deleteNode);
                //删除节点与后继节点值替换
                deleteNode.setData(afterNode.getData());
    
                //当前节点一定不存在左子树,有可能存在右子树
                if(afterNode.getRight()==null){
                    //当不存在右子数时,直接跟删除节点交换
                    deleteNode.setData(afterNode.getData());
                    //将对后继节点的引用置空
                    Node<String> parent = afterNode.getParent();
                    if(parent.getLeft()==afterNode){
                        parent.setLeft(null);
                    }else{
                        parent.setRight(null);
                    }
                    afterNode.setParent(null);
                }else{
                    //当存在右子树时,将右子数挂在后继节点的父节点下
                    Node<String> parent = afterNode.getParent();
                    if(parent.getLeft()==afterNode){
                        parent.setLeft(afterNode.getRight());
                    }else{
                        parent.setRight(afterNode.getRight());
                    }
                     afterNode.getRight().setParent(parent);
                }
    
            }else if(deleteNode.getLeft()!=null && deleteNode.getRight()==null){
                //只存在左子树
                //父节点指向左子树
                Node<String> parent = deleteNode.getParent();
                if(parent.getLeft()==deleteNode){
                    parent.setLeft(deleteNode.getLeft());
                }else{
                    parent.setRight(deleteNode.getLeft());
                }
                afterNode.getLeft().setParent(parent);
    			afterNode.setParent(null);
            }else if(deleteNode.getLeft()==null && deleteNode.getRight()!=null){
                //只存在右子树
                Node<String> parent = deleteNode.getParent();
                if(parent.getLeft()==deleteNode){
                    parent.setLeft(deleteNode.getRight());
                }else{
                    parent.setRight(deleteNode.getRight());
                }
                afterNode.getRight().setParent(parent);
                afterNode.setParent(null);
            }else{
                //叶子节点
                //将指向该节点父节点置空
                Node<String> parent = deleteNode.getParent();
                if(parent.getLeft()==deleteNode){
                    parent.setLeft(null);
                }else{
                    parent.setRight(null);
                }
                afterNode.setParent(null);
            }
            return result;
        }
    
    //节点查询
    public static <A extends String> Node<A> findNode(Node<A> root,A value){
            if(root ==null){
                return null;
            }
            Node<A> cnode = root;
            while(cnode!=null){
                if(value.compareTo(cnode.getData())==0){
                    return cnode;
                }
    
                if(Integer.parseInt(value)<Integer.parseInt(cnode.getData())){
                    cnode=cnode.left;
                    continue;
                }
    
                if(Integer.parseInt(value)>Integer.parseInt(cnode.getData())){
                    cnode=cnode.right;
                    continue;
                }
            }
            return null;
        }
    
    // 找到指定节点的后继节点
    public static Node<String> findAfterNode(Node<String> root,Node<String> targetNode){
            ArrayList<Node<String>> list = new ArrayList<>();
            midSercharStack(root,list);
            for (int i = 0; i < list.size(); i++) {
                if(Integer.valueOf(list.get(i).getData())==Integer.valueOf(targetNode.getData())){
                    return list.get(++i);
                }
            }
            return null;
        }
    //中序遍历树,并保存到列表中	
     public static void midSercharStack(Node<String> root, ArrayList<Node<String>> list){
         if(root==null){
             return;
         }
         midSercharStack(root.left,list);
         list.add(root);
         midSercharStack(root.right,list);
     }
    

    5.中序遍历方法 递归+非递归

    
    //非递归 中序遍历
    public static void midPrintNoback(Node<String> root){
       LinkedList<Node<String>> stack = new LinkedList<>();
        Node<String> p = root;
        while(p!=null || !stack.isEmpty()){
    
            if(p!=null){
                stack.push(p);
                p=p.left;
    
            }else{
                Node<String> pop = stack.pop();
                System.out.println(pop.getData());
                p=pop.right;
            }
        }
     }
     //递归中序遍历
    public static void midPrint(Node<String> root){
        if(root==null){
            return;
        }
        midPrint(root.getLeft());
        System.out.println(root.getData()==null?"":root.getData());
        midPrint(root.getRight());
    }
    

    6.测试

     public static void main(String[] args) {
    		//先打印一遍树
            midPrint(tree);
            System.out.println("-------");
            //删除最复杂的 7节点
            String s = deleteNode(tree, "7");
            //打印删除后的树
            midPrint(tree);
        }
    

    结果如下,可以发现,删除后,节点7已经不在了
    在这里插入图片描述

    7.附插入时,定位要插入的父节点

    public static <A extends String> Node<A> findInsertNode(Node<A> root,A value){
       if(root ==null){
           return null;
       }
       Node<A> cnode = root;
       Node<A> pnode=null;
       while(cnode!=null){
           if(Integer.parseInt(value)<=Integer.parseInt(cnode.getData())){
               pnode=cnode;
               cnode=cnode.left;
               continue;
           }
    
           if(Integer.parseInt(value)>Integer.parseInt(cnode.getData())){
               pnode=cnode;
               cnode=cnode.right;
               continue;
           }
       }
       return pnode;
    }
    
    展开全文
  • 二叉树删除节点 让deleNode节点的左子节点直接顶替deleNode,“让deleNode节点的左子节点的最大节点“指向“delete节点的右子节点” 这两种方法有什么不一样吗,都能实现二叉树的节点删除。 标题下面的是第二种方法 ...

    二叉树删除节点

    让deleNode节点的左子节点直接顶替deleNode,“让deleNode节点的左子节点的最大节点“指向“delete节点的右子节点”

    这两种方法有什么不一样吗,都能实现二叉树的节点删除。

    标题下面的是第二种方法
    package com.tjetc.Tree;
    
    
    import com.tjetc.Tree.printer.BinaryTreeInfo;
    
    
    public class BinarySearchTree implements BinaryTreeInfo {
    
    
        //根节点
        private Node root;
        //节点数量
        private int size;
    
    
        public void add(int element) {
            Node newNode = new Node(element);
            if (root == null) {
                //如果root是null,那么newNode给root
                root = newNode;
                //size数量+1
                size++;
            } else {
                //从根节点循环搜索树的节点的值跟传入的element比大小,如果节点的值大于element值,向节点的左子节点搜索,反之向右子节点搜索
                //最终搜索到左子节点或右子节点为空为止
                Node currentNode = root;
                Node parent = root;
    
    
                while (currentNode != null) {
                    //当前节点赋值给parent
                    parent = currentNode;
                    if (currentNode.element > element) {
                        //左子节点搜索
                        currentNode = currentNode.left;
                    } else if (currentNode.element < element) {
                        //右子节点搜索
                        currentNode = currentNode.right;
                    } else {
                        //直接返回不执行
                        return;
                    }
                }
                newNode.setPreNode(parent);
    
    
                //newNOde放到parent的左边还是右边
                if (parent.element > element) {
                    //放到左子节点
                    parent.left = newNode;
                } else {
                    //放到右子节点
                    parent.right = newNode;
                }
                size++;
            }
        }
    
    
    
    
        /**
         * 检索二叉树删除节点
         * <p>
         * 思路1.根据要删除的元素值,从根节点检索到对应的Node节点
         * 2.要删除的节点分三种情况
         * (1)要删除的是叶子节点直接删除
         * (2)要删除的节点右左子节点或者右子节点一个分支,需要判断
         * deleteNOde下一个节点是parent左子节点还是右子节点,
         * (3)要删除的节点右左子节点和右子节点,找出deleteNode的
         * 左子树的最大节点值(右子树的最小值),把最大节点值覆盖要
         * 删除的节点值,又回到了(1)或者(2)
         */
    
    
        public void deleteNode(int element) {
            Node currentNode = root;
            while (currentNode.element != element) {
                //当前节点赋值给parent
                if (currentNode.element > element) {
                    //左子节点搜索
                    currentNode = currentNode.left;
                } else if (currentNode.element < element) {
                    //右子节点搜索
                    currentNode = currentNode.right;
                } else {
                    //直接返回不执行
                    return;
                }
            }
            Node preNode = currentNode.preNode;
            if (preNode == null) {
                root = root.right;
                return;
            }
            //要删除的是叶子节点
            if (currentNode.left == null && currentNode.right == null) {
                if (preNode.element > currentNode.element) {
                    preNode.left = null;
                } else {
                    preNode.right = null;
                }
                //要删除的是有左子节点或者右子节点的节点;
            } else if (currentNode.left == null || currentNode.right == null) {
                //要删除的节点有左子节点
                if (currentNode.right == null) {
                    //判断要删除的节点是父节点的左子节点还是右子节点
                    if (currentNode.element > preNode.element) {
                        preNode.right = currentNode.left;
                    } else {
                        preNode.left = currentNode.left;
                    }
                }
                //要删除的节点有右子节点
                if (currentNode.left == null) {
                    //判断要删除的节点是父节点的左子节点还是右子节点
                    if (currentNode.element < preNode.element) {
                        preNode.left = currentNode.right;
                    } else {
                        preNode.right = currentNode.right;
                    }
                }
                //要删除的节点同时有左子节点和右子节点
            } else {
                //找左子树最大的覆盖要删除的节点
                Node leftChildMaxNode = currentNode.left;
                while (leftChildMaxNode.right != null) {
                    leftChildMaxNode = leftChildMaxNode.right;
                }
                preNode = leftChildMaxNode.preNode;
                currentNode.element = leftChildMaxNode.element;
                preNode.right = leftChildMaxNode.left;
            }
            size--;
        }
    
    
    
    
        //先序遍历
        public void preorder() {
            //顺序根左右
            preorderTravelsal(root);
        }
    
    
        private void preorderTravelsal(Node node) {
            if (node == null) {
                return;
            }
            System.out.println(node.element); //根
            preorderTravelsal(node.left); //左
            preorderTravelsal(node.right); //右
        }
    
    
        //中序便利
        public void inorder() {
            //左根右
            inorderTravelsal(root);
        }
    
    
        public void inorderTravelsal(Node node) {
            if (node == null) {
                return;
            }
            inorderTravelsal(node.left);
            System.out.println(node.element);
            inorderTravelsal(node.right);
        }
    
    
        //后序遍历
        public void postorder() {
            //左右根
            postorderTravelsal(root);
        }
    
    
    
    
        public void postorderTravelsal(Node node) {
            if (node == null) {
                return;
            }
            postorderTravelsal(node.left);
            postorderTravelsal(node.right);
            System.out.println(node.element);
        }
    
    
        /**
         * 返回根节点
         *
         * @return
         */
        @Override
        public Object root() {
            return root;
        }
    
    
        /**
         * 打印树需要返回node对应的左子节点
         *
         * @param node
         * @return
         */
        @Override
        public Object left(Object node) {
            return ((Node) node).left;
        }
    
    
        /**
         * 打印树需要的node对应的右子节点
         *
         * @param node
         * @return
         */
        @Override
        public Object right(Object node) {
            return ((Node) node).right;
        }
    
    
        @Override
        public Object string(Object node) {
            return ((Node) node).element;
        }
    
    
    
    
        class Node {
            /**
             * 保存数据
             */
            private int element;
            /**
             * 左子节点
             */
            private Node left;
            /**
             * 右子节点
             */
            private Node right;
    
    
            private Node preNode;
    
    
            public Node getPreNode() {
                return preNode;
            }
    
    
            public void setPreNode(Node preNode) {
                this.preNode = preNode;
            }
    
    
            public Node(int element) {
                this.element = element;
            }
    
    
            public int getElement() {
                return element;
            }
    
    
            public void setElement(int element) {
                this.element = element;
            }
    
    
            public Node getLeft() {
                return left;
            }
    
    
            public void setLeft(Node left) {
                this.left = left;
            }
    
    
            public Node getRight() {
                return right;
            }
    
    
            public void setRight(Node right) {
                this.right = right;
            }
        }
    }
    
    展开全文
  • 一、二叉树删除节点的思路图解 二、二叉树删除节点的示例代码 1、代码 package com.rf.springboot01.dataStructure.tree; /** * @description: 二叉树删除节点示例 * @author: xiaozhi * @create: 2020-08-28 ...

    一、二叉树删除节点的思路图解

    在这里插入图片描述

    二、二叉树删除节点的示例代码

    1、代码

    package com.rf.springboot01.dataStructure.tree;
    
    /**
     * @description: 二叉树删除节点示例
     * @author: xiaozhi
     * @create: 2020-08-28 21:07
     */
    public class BinaryTreeDemoThree {
        public static void main(String[] args) {
            //创建二叉树
            BinaryTree1 binaryTree1 = new BinaryTree1();
            //创建需要的结点
            UsersNode root = new UsersNode(1,"张三");
            UsersNode node2 = new UsersNode(2, "李四");
            UsersNode node3 = new UsersNode(3, "王五");
            UsersNode node4 = new UsersNode(4, "小志");
            UsersNode node5 = new UsersNode(5, "Tom");
            //手动创建该二叉树
            binaryTree1.setRoot(root);//创建根节点
            root.setLeft(node2);//创建根节点左边子节点
            root.setRight(node3);//创建根节点右边子节点
            node3.setRight(node4);//创建根节点右边子节点的右边子节点
            node3.setLeft(node5);//创建根节点右边子节点的左边子节点
    
            System.out.println("删除前,前序遍历结果如下===============");
            binaryTree1.preOrder();//输出的no的顺序为1,2,3,5,4
            binaryTree1.delNode(3);
            System.out.println("删除后,前序遍历结果如下===============");
            binaryTree1.preOrder();//输出的no的顺序为1,2
    
        }
    }
    /**
     * @Description: 创建BinaryTree1 二叉树
     * @Param:
     * @Author: xz
     * @return:
     * @Date: 2020-08-28 21:15
     */
    class BinaryTree1{
        private UsersNode root;
    
        public void setRoot(UsersNode root) {
            this.root = root;
        }
    
        //前序遍历方法
        public void preOrder(){
            if(root !=null){
                this.root.preOrder();
            }else{
                System.out.println("二叉树为空,无法遍历");
            }
        }
        //删除结点
        public void delNode(int no) {
            if(root != null) {
                //如果只有一个root结点, 这里立即判断root是不是就是要删除结点
                if(root.getNo() == no) {
                    root = null;
                } else {
                    //递归删除
                    root.deleteNode(no);
                }
            }else{
                System.out.println("空树,不能删除~");
            }
        }
    
    }
    /**
     * @Description: 先创建UserNode结点类
     * @Author: xz
     * @Date: 2020-08-28 21:10
     */
    class UsersNode{
    
        private int no;
        private String name;
        private UsersNode left;//左节点,默认为null
        private UsersNode right;//左节点,默认为null
    
        public UsersNode(int no, String name) {
            this.no = no;
            this.name = name;
        }
    
        public int getNo() {
            return no;
        }
    
        public void setNo(int no) {
            this.no = no;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public UsersNode getLeft() {
            return left;
        }
    
        public void setLeft(UsersNode left) {
            this.left = left;
        }
    
        public UsersNode getRight() {
            return right;
        }
    
        public void setRight(UsersNode right) {
            this.right = right;
        }
    
        @Override
        public String toString() {
            return "UsersNode{" +
                    "no=" + no +
                    ", name='" + name + '\'' +
                    '}';
        }
    
        //前序遍历方法
        public void preOrder(){
            //先输出父节点
            System.out.println(this);
            //递归向左子树前序遍历
            if(this.left != null){
                this.left.preOrder();
            }
            //递归向右子树前序遍历
            if(this.right != null){
                this.right.preOrder();
            }
        }
        //删除节点方法
        public void deleteNode(int no){
            //如果当前节点的左子节点不为空,并且左子节点就是要删除节点,就将this.left=null; 并且返回(结束递归删除)
            if(this.left != null && this.left.no == no){
                this.left=null;
                return;
            }
            //如果当前节点的右子节点不为空,并且右子节点就是要删除节点,就将this.right=null;并且返回(结束递归删除)
            if(this.right != null && this.right.no == no){
                this.right=null;
                return;
            }
            //要向左子树进行递归删除
            if(this.left !=null){
                this.left.deleteNode(no);
            }
            //向右子树进行递归删除
            if(this.right !=null){
                this.right.deleteNode(no);
            }
        }
    
    
    }
    
    

    2、删除节点5的运行结果如下:
    在这里插入图片描述
    3、删除节点3的运行结果如下:
    在这里插入图片描述

    展开全文
  • 二叉树删除节点-简答版 要求 1.如果是叶子节点则删除该节点 2.如果是非叶子节点则删除子树 代码实现 class BinaryTree { private HeroNode root; public void setRoot(HeroNode root) { this.root = root; } ...
  • 二叉树删除节点 删除分为四种情况 这个节点左右孩子都有 这个节点没有左右孩子 这个节点只有左孩子 这个节点只有右孩子 1.查找节点位置 struct TreeNode *p = NULL;//遍历指针 struct TreeNode *fp = NULL;//...
  • 二叉树删除节点时,分为两种情况,删除节点为叶子节点与非叶子节点。 首先判断根节点是否要删除的节点。如果是,则将该二叉树变为空树;否则判断左子节点与右子节点是否要删除的节点。 如果是,删除以该节点为根...
  • Java-二叉树删除节点

    2020-10-21 22:20:22
    思路分析 首先先处理: 考虑如果树是空树root,如果只有一个root节点,则等价二叉树置空 然后进行下列操作: 1.因为我们的二叉树是单向的,所以我们...4.如果第二步和第三步没有删除节点,那我们就向左子树进行递归 5
  • 首先定义结点类 class Node :public class Node {public Node leftchild=null;public Node rightchild=null;...}然后再定义二叉树类 class Btreepublic class Btree{// 删除值为val的节点public void delete(In...
  • 以下是二叉树删除节点的代码,C Primer Plus 第5版中的第17章的原代码bool DeleteItem(const Item *pi,Tree *ptree){Pair look;look=SeekItem(pi,ptree);if(look.child==NULL)return false;if(look.parent==NULL) /*...
  • 在原课程中二叉树删除节点的操作由二叉树类调用节点的删除方法进行递归,因为原返回值类型为void类型 会导致在递归过程中没有合适的方式让方法及时return停止,导致void方法一直执行到底,虽然结果一样但明显是不...
  • Day60:删除二叉搜索树的某个节点1 题目给定一...一般来说,删除节点可分为两个步骤:首先找到需要删除的节点;如果找到了,删除它。说明:要求算法时间复杂度为 O(h),h 为树的高度。示例:root = [5,3,6,2,4,null,7...
  • 一颗树有三种遍历方式,那相对应的应该也有三种删除节点的方式,但所有书中提到的删除节点貌似都是基于中序遍历的,但都没有提到这一点,不知我的想法是否正确?
  • 从根节点往下分别查找左子树和右子树的最大节点,再比较左子树,右子树,根节点的大小得到结果,在得到左子树和右子树最大节点的过程相似,因此可以采用递归的 //树节点结构 publicclassTreeNode{ TreeNodeleft...
  • 标题删除的节点拥有左子节点和右子节点,找出deleteNode的左子树的最大节点值(或者右子树的最小值),用最大节点值覆盖要删除节点的值,然后处理删除最大节点值 public void delete(int key) throws Exception { ...
  • 二叉树删除节点+思路分析

    千次阅读 2021-03-25 19:32:10
    思路分析 代码实现 ![在这里插入代码片](https://img-blog.csdnimg.cn/20210325193201194.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ...t_70)
  • 创建Node节点 public class Node { int value; Node left; Node right; public Node(int value) { ... * @param value 希望删除节点 * @return 如果找到返回该节点,否则返回null */ public Node search

空空如也

空空如也

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

二叉树删除节点