Java版二叉树的删除

最新推荐文章于 2024-09-17 14:02:05 发布
最新推荐文章于 2024-09-17 14:02:05 发布
阅读量1.3k 收藏 8
点赞数 2
文章标签： 二叉树 删除节点 中序遍历 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37837621/article/details/123103007
版权

文章收藏的好句子：失败是个好事，失败教会我们如何成功，一个人要想成事，就得拿得起，放得下。

目录

1、二叉树的删除

     1、1 根节点的删除

     1、2 非叶子节点（该节点含有子节点但该节点又不是根节点）的删除

     1、3 叶子节点的删除

1、二叉树的删除

说二叉树的删除之前，我们先给自己的二叉树定义一些规则：左子节点的值小于等于父节点的值，右子节点的值大于父节点的值，也就是说进行这棵二叉树的中序遍历是升序的；关于二叉树的中序遍历，如果不懂的话，可以看Java版的数据结构和算法（四）这篇文章；二叉树的删除可分为3种情况，它们是根节点的删除、非叶子节点（该节点含有子节点但该节点又不是根节点）的删除和叶子节点的删除，下面我们对它们一个一个的进行分析。

1、1 根节点的删除

以根节点形成一棵二叉树时分为4种情况：根节点没有子节点、根节点只有左子树、根节点只有右子树和根节点左右子树都有。

1）根节点没有子节点而进行删除根节点的思路：

（1）直接将根节点置空即可。

2）根节点只有左子树而进行删除根节点的思路：

（1）直接将根节点指向根节点的左子树。

3）根节点只有右子树而进行删除根节点的思路：

（1）直接将根节点指向根节点的右子树。


4）根节点左右子树都有而进行删除根节点的思路：

（1）先拿到根节点的左右2棵子树，用根节点指向右子树，这样就实现了删除根节点。

（2）这样就形成了2棵二叉树，我们还得把2棵二叉树组合成一棵二叉树，因为旧的根节点的右子节点的值一定是大于旧的根节点的左子节点的值，这个不用怀疑的，因为前面我们已经制定了二叉树的一些规则，所以旧的根节点的右子节点就会成为新的根节点。

（3）旧的根节点的左子节点一定是挂在新的根节点的子节点或者子子节点之中，依次类推是成为谁的子节点，一开始假定新的根节点即将成为旧的根节点的左子节点的 “父节点”。

（4）如果旧的根节点的左子节点的值小于等于 “父节点” 的值并且 “父节点” 的左子节点为空，那么就将旧的根节点的左子节点设置为 “父节点” 的左子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 旧的根节点的左子节点的父节点，那么就不必走（5-7）的步骤。

（5）如果（4）的条件不成立，就再往下做判断：如果旧的根节点的左子节点的值大于 “父节点” 的值并且 “父节点” 的右子节点为空，那么就将旧的根节点的左子节点设置为 “父节点” 的右子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 旧的根节点的左子节点的父节点，那么就不必走（6-7）的步骤。

（6）如果（5）的条件不成立，就又往下做判断：如果 “父节点” 的左子节点不为空，“父节点” 就指向 “父节点” 的左子节点，那么旧的 “父节点” 的左子节点就成为了新的 “父节点”，就不必往下走（7）的步骤，然后直接又回到步骤（3）去。

（7）如果（6）的条件不成立，就又再往下做判断：“父节点” 的右子节点不为空，“父节点” 就指向 “父节点” 的右子节点，那么旧的 “父节点” 的右子节点就成为了新的 “父节点”，然后直接又回到步骤（3）去。

在删除根节点的情况中，根节点没有子节点而进行删除根节点、根节点只有左子树而进行删除根节点和根节点只有右子树而进行删除根节点这3个比较好理解，而根节点左右子树都有而进行删除根节点可能没那么好理解，所以我们举个例子，我们先画一张图，图1所示：

87dfff130f02e466cd9a33a1830468eb.png

我们要删除图1的根节点，那么就会变成2个二叉树，如图2所示：

86195f88f0c9bce3cde7611bfeea2584.png

首先按照上面所说的规则，左子树的根节点4要比右子树的根节点11小，所以说2个二叉树组合成一棵二叉树时，右子树的根节点11会成新的二叉树的最终根节点，4节点将会成为节点11、10、13、12 中的一个子节点，由于11节点的左右节点不为空，所以节点4不能做为节点11的子节点，所以先递归往11节点的左子节点10看看，发现10节点左子节点为空且10大于4，所以4节点就成为10节点的左子节点，4节点设置成为10节点的左子节点后，就不会再递归往11节点的右子节点判断了，图2中组合成新的二叉树如图3所示：

6bd1746c25226e97c7e4bc97fecf2971.png

中序遍历出来的结果为：1 2 3 4 5 6 7 8 10 11 12 13 ，后面我会用代码测试一把给各位看看。

1、2 非叶子节点（该节点含有子节点但该节点又不是根节点）的删除

因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点，所以当前结点的子结点才是主角。

注意：我们这里所说的删除非叶子节点是删除当前节点的子节点

删除当前节点的子节点（非叶子节点）就会存在以下几种情况，我们将以下几种情况列出来并进行思路分析；

1）删除当前节点的左子节点且当前节点的左子节点只有左子节点。

（1）获取当前节点的左子节点的左子节点并用一个临时变量保存它。

（2）用当前节点的左子节点指向这个临时变量，这样就实现了删除原先当前节点的左子节点。

2）删除当前节点的左子节点且当前节点的左子节点只有右子节点

（1）获取当前节点的左子节点的右子节点并用一个临时变量（我们叫它child吧）保存它。

（2）将当前节点的左子节点置空，假设当前节点是 child 的 “父节点”。

（3）如果 child 的值小于等于 “父节点” 的值并且 “父节点” 的左子节点为空，那么就将 child 设置为 “父节点” 的左子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 child 的父节点，那么就不必走（4-6）的步骤。

（4）如果（3）的条件不成立，就再往下做判断：如果 child 的值大于 “父节点” 的值并且 “父节点” 的右子节点为空，那么就将 child 设置为 “父节点” 的右子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 child 的父节点，那么就不必走（5-6）的步骤。

（5）如果（4）的条件不成立，就又往下做判断：如果 “父节点” 的左子节点不为空，“父节点” 就指向 “父节点” 的左子节点，那么旧的 “父节点” 的左子节点就成为了新的 “父节点”，就不必往下走（6）的步骤，然后直接又回到步骤（3）去。

（6）如果（5）的条件不成立，就又再往下做判断：“父节点” 的右子节点不为空，“父节点” 就指向 “父节点” 的右子节点，那么旧的 “父节点” 的右子节点就成为了新的 “父节点”，然后直接又回到步骤（3）去。


就拿图1的二叉树来说，如果删除5节点，那么删除后图1的中序遍历为：1 2 3 4 6 7 8 9 10。

3）删除当前节点的左子节点且当前节点的左子节点都有左右子节点

（1）获取当前节点的左子节点的左子节点并用一个临时变量（我们叫它 child1）保存它。

（2）获取当前节点的左子节点的右子节点并用一个临时变量（我们叫它 child2）保存它。

（3）用当前节点的左子节点指向 child1，把 child1 假设为 “父节点”。

（4）如果 child2 的值小于等于 “父节点” 的值并且 “父节点” 的左子节点为空，那么就将 child2 设置为 “父节点” 的左子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 child2 的父节点，那么就不必走（5-7）的步骤。

（5）如果（4）的条件不成立，就再往下做判断：如果 child2 的值大于 “父节点” 的值并且 “父节点” 的右子节点为空，那么就将 child2 设置为 “父节点” 的右子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 child2 的父节点，那么就不必走（6-7）的步骤。

（6）如果（5）的条件不成立，就又往下做判断：如果 “父节点” 的左子节点不为空，“父节点” 就指向 “父节点” 的左子节点，那么旧的 “父节点” 的左子节点就成为了新的 “父节点”，就不必往下走（7）的步骤，然后直接又回到步骤（3）去。

（7）如果（6）的条件不成立，就又再往下做判断：“父节点” 的右子节点不为空，“父节点” 就指向 “父节点” 的右子节点，那么旧的 “父节点” 的右子节点就成为了新的 “父节点”，然后直接又回到步骤（3）去。


就拿图1来举个例子吧，我们要删除4节点，由于4节点的左子节点2比4节点的右子节点7小，所以根节点的左子节点就变成了7节点，然后2节点就以7节点为 “父节点”，发现7节点的左右子节点不为空，然后先递归7节点的左子节点5，把5节点当做是新的 “父节点”，发现5节点的左子节点为空且2节点的值（序号为2嘛）比5节点的值（序号为5嘛）小，所以5节点的左子节点就是2节点，删除图1中的4节点后，图1中的二叉树变成如下图4所示：

da609a5e28416821a65de9ecb1541935.png

图4中二叉树中序遍历的结果为：1 2 3 5 6 7 8 9 10 11 12 13。

4）删除当前节点的右子节点且当前节点的右子节点只有右子节点。

（1）获取当前节点的右子节点的右子节点并用一个临时变量保存它。

（2）用当前节点的右子节点指向这个临时变量，这样就实现了删除原先当前节点的右子节点。

5）删除当前节点的右子节点且当前节点的右子节点只有左子节点。

（1）获取当前节点的右子节点的左子节点并用一个临时变量（我们叫它child）保存它。

（2）将当前节点的右子节点置空，假设当前节点是 child 的 “父节点”。

（3）如果 child 的值小于等于 “父节点” 的值并且 “父节点” 的左子节点为空，那么就将 child 设置为 “父节点” 的左子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 child 的父节点，那么就不必走（4-6）的步骤。

（4）如果（3）的条件不成立，就再往下做判断：如果 child 的值大于 “父节点” 的值并且 “父节点” 的右子节点为空，那么就将 child 设置为 “父节点” 的右子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 child 的父节点，那么就不必走（5-6）的步骤。

（5）如果（4）的条件不成立，就又往下做判断：如果 “父节点” 的左子节点不为空，“父节点” 就指向 “父节点” 的左子节点，那么旧的 “父节点” 的左子节点就成为了新的 “父节点”，就不必往下走（6）的步骤，然后直接又回到步骤（3）去。

（6）如果（5）的条件不成立，就又再往下做判断：“父节点” 的右子节点不为空，“父节点” 就指向 “父节点” 的右子节点，那么旧的 “父节点” 的右子节点就成为了新的 “父节点”，然后直接又回到步骤（3）去。

6）删除当前节点的右子节点且当前节点的右子节点都有左右子节点

（1）获取当前节点的右子节点的左子节点并用一个临时变量（我们叫它 child1）保存它。

（2）获取当前节点的右子节点的右子节点并用一个临时变量（我们叫它 child2）保存它。

（3）用当前节点的右子节点指向 child1，把 child1 假设为 “父节点”。

（4）如果 child2 的值小于等于 “父节点” 的值并且 “父节点” 的左子节点为空，那么就将 child2 设置为 “父节点” 的左子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 child2 的父节点，那么就不必走（5-7）的步骤。

（5）如果（4）的条件不成立，就再往下做判断：如果 child2 的值大于 “父节点” 的值并且 “父节点” 的右子节点为空，那么就将 child2 设置为 “父节点” 的右子节点，完成2棵二叉树的组合，这时候 “父节点” 就真的是 child2 的父节点，那么就不必走（6-7）的步骤。

（6）如果（5）的条件不成立，就又往下做判断：如果 “父节点” 的左子节点不为空，“父节点” 就指向 “父节点” 的左子节点，那么旧的 “父节点” 的左子节点就成为了新的 “父节点”，就不必往下走（7）的步骤，然后直接又回到步骤（3）去。

（7）如果（6）的条件不成立，就又再往下做判断：“父节点” 的右子节点不为空，“父节点” 就指向 “父节点” 的右子节点，那么旧的 “父节点” 的右子节点就成为了新的 “父节点”，然后直接又回到步骤（3）去。


1、3 叶子节点的删除

这里删除叶子节点时，也是不能直接把当前节点当作叶子节点，应该把当前节点的左子节点或者当前节点的右子节点当做叶子节点，删除步骤如下：

（1）如果当前结点的左子结点不为空，并且左子结点就是要删除结点，就将 this.left=nul 并且就返回(结束递归删除)。

（2）如果当前结点的右子结点不为空，并且右子结点就是要删除结点，就将 this.right=null; 并且就返回(结束递归删除)。

（3）如果第（1）和第（2）步没有删除结点,那么我们就需要向左子树进行递归删除。

（4）如果第（3）步也没有删除结点，则应当向右子树进行递归册除。

好，说了那么多，我们写一下代码测试一把；

（1）节点类 Node ：

public class Node {
  private int no;
  private Node left;
  private Node right;


  public Node(int no) {
    super();
    this.no = no;
  }


  public int getNo() {
    return no;
  }


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


  @Override
  public String toString() {
    return "Node [no=" + no + "]";
  }


}

（2）主程序类 Test ：

public class Test {
  private Node root;


  public static void main(String[] args) {
    
  }


  // 二叉树的中序遍历
  private void infixOrder() {
    if (root == null) {
      System.out.println("这是一棵空的二叉树，无法进行中序遍历");
    } else {
      infixOrder(root);
    }
  }


  // 中序遍历
  private void infixOrder(Node node) {
    if (node.getLeft() != null) {
      infixOrder(node.getLeft());
    }


    System.out.println(node);


    if (node.getRight() != null) {
      infixOrder(node.getRight());
    }
  }


  private void deleteNode(int no) {
    if (root == null) {
      System.out.println("这是一棵空二叉树，无法删除节点");
      return;
    }
    if (!deleteRoot(no)) {
      boolean isSuccess = deleteNode(root, no);
      if (isSuccess) {
        System.out.println("删除" + no + "节点成功");
      } else {
        System.out.println("没有该" + no + "节点，删除失败");
      }
    } else {
      System.out.println("删除根节点成功");
    }
  }


  private boolean deleteRoot(int no) {


    // 要删除的节点是根节点
    if (root.getNo() == no) {


      // 要删除的根节点，没有左子树和右子树
      if (root.getLeft() == null && root.getRight() == null) {
        root = null;


        // 要删除的根节点，都有左右子树
      } else if (root.getLeft() != null && root.getRight() != null) {
        Node left = root.getLeft();
        root = root.getRight();// 实现删除原来的 root
        combinationBinaryTreeTry(root, left);


        // 要删除的根节点，只有左子树
      } else if (root.getLeft() != null) {
        root = root.getLeft();


        // 要删除的根节点，只有右子树
      } else {
        root = root.getRight();
      }
      return true;
    }
    return false;
  }


  /**
   * 该方法是组合一棵新的二叉树
   * 
   * @param parent
   *            父节点
   * @param left
   *            作为 parent 的子节点或者作为 parent的子节点的子节点，以此类推...
   */
  private void combinationBinaryTreeTry(Node parent, Node left) {


    // 如果parent的左子节点为空，那么left的no 一定小于等于 parent的no
    if (parent.getLeft() == null) {
      parent.setLeft(left);


      // 如果这个条件满足，证明parent的左子节点不为空，那么left的no 一定小于等于 parent的no
      // 所以left不能作为parent右子节点
    } else if (parent.getRight() == null) {
      combinationBinaryTree(parent.getLeft(), left);


      // parent的左右子节点不为空
    } else {
      combinationBinaryTree(parent.getLeft(), left);
    }
  }


  /**
   * @param parent 将要作为父节点
   * @param child 将要作为子节点
   * @param return true 则说明组合一棵二叉树成功
   */
  private boolean combinationBinaryTree(Node parent, Node child) {
    int childNo = child.getNo();
    int parentNo = parent.getNo();


    // 如果 “将要作为父节点” 的序号大于等于 “将要作为子节点”的序号
    // 并且 “将要作为父节点” 的左子节点是空的
    if (childNo <= parentNo && parent.getLeft() == null) {
      parent.setLeft(child);
      return true;


      // 如果 “将要作为父节点” 的序号小于于 “将要作为子节点”的序号
      // 并且 “将要作为父节点” 的右子节点是空的
    } else if (childNo > parentNo && parent.getRight() == null) {
      parent.setRight(child);
      return true;
    } 
    
    boolean result = false;
    
    if (parent.getLeft() != null) {


      // 递归调用 combinationBinaryTree 方法，有可能要将child挂载在parent的左子节点
      //如果已经挂载成功，就不必在遍历 右子节点了，也就是不去执行注释1的代码了
      result = combinationBinaryTree(parent.getLeft(), child);
      if (result) {
        return true;
      }
    } 
    
    //1、
    if (parent.getRight() != null) {


      // 递归调用 combinationBinaryTree 方法，有可能要将child挂载在parent的右子节点
      result = combinationBinaryTree(parent.getRight(), child);
    }
    
    return result;
  }


  /**
   * 
   * @param node 二叉树中的当前节点
   * @param no 要删除的节点的序号
   * @return 返回 true 表示删除成功
   */
  private boolean deleteNode(Node node, int no) {


    // 如果删除的是当前节点的左子节点（非叶子节点来的），当前节点的左子节点又有左右子节点
    if (node.getLeft() != null && node.getLeft().getNo() == no
        && node.getLeft().getLeft() != null
        && node.getLeft().getRight() != null) {
      Node parent = node.getLeft().getRight();
      Node child = node.getLeft().getLeft();
      node.setLeft(parent);//重置当前节点的左子节点
      combinationBinaryTree(parent, child);
      return true;


      // 如果删除的是当前节点的左子节点（非叶子节点来的），当前节点的左子节点只有左子节点
    } else if (node.getLeft() != null && node.getLeft().getNo() == no
        && node.getLeft().getLeft() != null
        && node.getLeft().getRight() == null) {
      Node child = node.getLeft().getLeft();
      node.setLeft(null);
      combinationBinaryTree(node, child);
      return true;


      // 如果删除的是当前节点的左子节点（非叶子节点来的），当前节点的左子节点只有右子节点
    } else if (node.getLeft() != null && node.getLeft().getNo() == no
        && node.getLeft().getLeft() == null
        && node.getLeft().getRight() != null) {
      Node child = node.getLeft().getRight();
      node.setLeft(null);//重置当前节点的左子节点
      combinationBinaryTree(node, child);
      return true;


      // 如果删除的是当前节点的右子节点（非叶子节点来的），当前节点的右子节点又有左右子节点
    } else if (node.getRight() != null && node.getRight().getNo() == no
        && node.getRight().getLeft() != null
        && node.getRight().getRight() != null) {
      Node parent = node.getRight().getRight();
      Node child = node.getRight().getLeft();
      node.setRight(parent);//重置当前节点的右子节点
      combinationBinaryTree(parent, child);
      return true;


      // 如果删除的是当前节点的右子节点（非叶子节点来的），当前节点的右子节点只有左子节点
    } else if (node.getRight() != null && node.getRight().getNo() == no
        && node.getRight().getLeft() != null
        && node.getRight().getRight() == null) {
      Node child = node.getRight().getLeft();
      node.setRight(null);//重置当前节点的右子节点
      combinationBinaryTree(node, child);
      return true;


      // 如果删除的是当前节点的右子节点（非叶子节点来的），当前节点的右子节点只有右子节点
    } else if (node.getRight() != null && node.getRight().getNo() == no
        && node.getRight().getLeft() == null
        && node.getRight().getRight() != null) {
      Node right = node.getRight().getRight();
      node.setRight(right);
      return true;


      // 删除的是当前节点的左子节点（叶子节点来的）
    } else if (node.getLeft() != null && node.getLeft().getNo() == no) {
      node.setLeft(null);
      return true;


      // 删除的是当前节点的右子节点（叶子节点来的）
    } else if (node.getRight() != null && node.getRight().getNo() == no) {
      node.setRight(null);
      return true;
    }
    boolean deleteResult = false;
    
    //向左子节点递归
    if (node.getLeft() != null) {
      deleteResult = deleteNode(node.getLeft(), no);
      if (deleteResult) {
        return true;
      }
    }
    
    //向右子节点递归
    if (node.getRight() != null) {
      deleteResult = deleteNode(node.getRight(), no);
    }
    return deleteResult;
  }


  // 创建一棵二叉树
  private void createBinaryTree() {
    Node[] nodes = new Node[13];
    for (int i = 0; i < nodes.length; i++) {
      nodes[i] = new Node(i + 1);
    }
    root = nodes[8];// 根节点的序号为9
    root.setLeft(nodes[3]);// 设置根节点的左子节点（序号为4）
    root.setRight(nodes[10]);// 设置根节点的右子节点（序号为11）
    nodes[10].setLeft(nodes[9]);// 设置11节点的左子节点（序号为10）
    nodes[10].setRight(nodes[12]);// 设置11节点的右子节点（序号为13）
    nodes[12].setLeft(nodes[11]);// 设置13节点的左子节点（序号为12）
    nodes[3].setLeft(nodes[1]);// 设置4节点的左子节点（序号为2）
    nodes[1].setLeft(nodes[0]);// 设置2节点的左子节点（序号为1）
    nodes[1].setRight(nodes[2]);// 设置2节点的右子节点（序号为3）
    nodes[3].setRight(nodes[6]);// 设置4节点的右子节点（序号为7）
    nodes[6].setLeft(nodes[4]);// 设置7节点的左子节点（序号为5）
    nodes[6].setRight(nodes[7]);// 设置7节点的右子节点（序号为8）
    nodes[4].setRight(nodes[5]);// 设置5节点的右子节点（序号为6）
  }
}

好了，我们就拿图1的二叉树测试一把；

（1）删除根节点（根节点左右子树都有而进行删除根节点的思路），程序入口调用如下所示：

public static void main(String[] args) {
    Test test = new Test();


    // 创建图1中的二叉树
    test.createBinaryTree();
    test.deleteNode(9);


    // 中序遍历
    test.infixOrder();
}

日志打印如下所示：

6694b8107ea12416668e0dfa918d621d.png

（2） 删除非叶子节点（删除当前节点的左子节点且当前节点的左子节点只有右子节点），删除5节点，程序入口调用如下所示：

public static void main(String[] args) {
    Test test = new Test();


    // 创建图1中的二叉树
    test.createBinaryTree();
    test.deleteNode(5);


    // 中序遍历
    test.infixOrder();
 }

日志打印如下所示：

8220d7109665b338d9df783116ff3a74.png

（3） 删除非叶子节点（删除当前节点的右子节点且当前节点的右子节点只有左子节点），删除13节点，程序入口调用如下所示：

public static void main(String[] args) {
    Test test = new Test();


    // 创建图1中的二叉树
    test.createBinaryTree();
    test.deleteNode(13);


    // 中序遍历
    test.infixOrder();
}

日志打印如下所示：

ef6f3ccb6623022ef0348a83c5c77373.png

（4）删除非叶子节点（删除当前节点的左子节点且当前节点的左子节点都有左右子节点），删除13节点，程序入口调用如下所示：

public static void main(String[] args) {
    Test test = new Test();


    // 创建图1中的二叉树
    test.createBinaryTree();
    test.deleteNode(4);


    // 中序遍历
    test.infixOrder();
}

日志打印如下所示：

69e1f07af5b5ccd8d13a236ff1173432.png

（5）删除非叶子节点（删除当前节点的右子节点且当前节点的右子节点都有左右子节点），删除11节点，程序入口调用如下所示：

public static void main(String[] args) {
    Test test = new Test();


    // 创建图1中的二叉树
    test.createBinaryTree();
    test.deleteNode(11);


    // 中序遍历
    test.infixOrder();
}

日志打印如下所示：

e44c468ce5df907d0bb581bd818c8594.png

（6）删除叶子节点（当前节点的左子节点），删除12节点（当前节点是11），程序入口调用如下所示：

public static void main(String[] args) {
    Test test = new Test();


    // 创建图1中的二叉树
    test.createBinaryTree();
    test.deleteNode(12);


    // 中序遍历
    test.infixOrder();
 }

日志打印如下所示：

7e87c6b4fe656e5eb4ee261e2eb9229c.png

（7）删除叶子节点（当前节点的右子节点），删除6节点（当前节点是5），程序入口调用如下所示：

public static void main(String[] args) {
    Test test = new Test();


    // 创建图1中的二叉树
    test.createBinaryTree();
    test.deleteNode(6);


    // 中序遍历
    test.infixOrder();
}

日志打印如下所示：

e1abb133d1733efe433c687f2190acac.png

java二叉树删除节点
weixin_54214681的博客
01-02 796
二叉树的删除要考虑三种情况 1.删除的节点是叶子节点2.删除的节点只有一个子树3.删除的节点有两个子树 删除的节点是叶子节点 找到删除的叶子结点tNode 找到目标节点的父节点pNode（考虑是否有父节点） 找到删除节点是父节点的左子树还是右子树 根据前边情况进行删除 右子树：p.rc=null 左子树：p.lc=null 删除的节点只有一个子树 找到删除的叶子结点tNode 找到目标节点的父节点pNode（考虑是否有父节点） 找到删除节点是父节点的左子树还是右子树 确定删除节点是左子树还是右子树 根据前边
删除二叉树节点java代码
04-16
删除二叉树节点java代码
二叉树删除操作(java)
weixin_30750335的博客
10-01 214
二叉树最复杂的步骤即为删除操作，此处只简单介绍一下具体思路： (1)如果待删除的节点是一片树叶，那么它可以被立即删除。然后将其父节点的相应子节点（左节点或右节点）至空。 (2)如果被删除的节点有一个子节点，那么把它的子节点直接连到它的父节点上即可。（Node:current,parent） (3)如果被删除的节点(a)有两个子节点，就不能简单的用它的一个子节点代替它。一般找到(a)的右子树中...
【Java数据结构】二叉树
最新发布
weixin_73276255的博客
09-17 639
树的概念，树的特征，两种特殊的二叉树，二叉树的性质，二叉树的基本操作，二叉树基本操作完整代码
Java学习——数据结构——二叉树的删除（简单实现）
qq_41853002的博客
05-22 179
学习尚硅谷韩顺平老师的Java数据结构笔记，详情请移步网站 要求 (1) 如果删除的节点是叶子节点，则删除该节点 (2) 如果删除的节点是非叶子节点，则删除该子树. (3) 测试，删除掉 5 号叶子节点 和 3 号子树. (4) 完成删除思路分析 完整代码请查阅上一篇博文 Node类 //递归删除结点 //如果删除的是叶子结点，则删除该结点 //如果删除的是非叶子结点，则删除该子树 public void delNode(int no){ //当前结点的左结点不为空
java有序二叉树的删除节点
m566666的博客
01-02 1576
删除节点时会有三种可能 1、删除的节点为叶子节点 我们如果删除为叶子节点，则步骤应该是： 1）先找到要删除的叶子节点 2）再找到要删除节点的父节点（考虑是否有父节点） 3）找到删除的节点是父节点的左子树还是右子树 4）根据前面的情况进行删除 2、删除的节点只有一个子树 步骤： 1）先找到要删除的节点 2）再找到要删除节点的父节点（考虑是否有父节点） 3）确定删除的节点是有左子树还是有右子树 4）找到删除的节点是父节点的左子树还是右子树 5）根据前面的情况进行删除 3、删除的节点有
排序二叉树的删除
weixin_45761237的博客
03-28 2471
排序二叉树的删除
JAVA 实现二叉树（链式存储结构）
09-02
在本文中，我们将探讨如何使用Java来实现一个二叉树，采用的是链式存储结构。 首先，我们来看链式存储结构在二叉树中的应用。链式存储结构是通过节点间的引用或指针连接各个节点，而不是像顺序存储结构那样使用数组...
Java二叉树算法实例.zip_java 二叉树_二叉树
09-22
这个名为"Java二叉树算法实例.zip"的压缩包显然是一个针对初学者的教程，旨在帮助他们理解并掌握二叉树的基本概念和常见算法。 首先，二叉树是由节点构成的数据结构，每个节点包含两个子节点，分别称为左子节点和右...
用java写二叉树
weixin_35754962的博客
01-03 258
当然可以! 下面是用 Java 实现二叉树的基本步骤: 定义二叉树的节点类型。 实现插入节点的方法。 实现遍历二叉树的方法，比如前序遍历、中序遍历、后序遍历。 实现查找节点的方法。 实现删除节点的方法。 下面是一个简单的二叉树的例子: public class BinaryTree { private Node root; public void insert(int va...
Java创建二叉树java
08-17
二叉树的查找、插入、删除和输出根节点到当前节点的路径 二叉树的前序遍历，中序遍历和后续遍历 TreeNode.java --定义树节点 Mytree.java----创建树结构和上述功能函数 TestTree.java --测试上述的功能
java二叉树的删除_二叉树删除操作(java)
weixin_26857669的博客
02-21 859
二叉树最复杂的步骤即为删除操作，此处只简单介绍一下具体思路：(1)如果待删除的节点是一片树叶，那么它可以被立即删除。然后将其父节点的相应子节点(左节点或右节点)至空。(2)如果被删除的节点有一个子节点，那么把它的子节点直接连到它的父节点上即可。(Node:current,parent)(3)如果被删除的节点(a)有两个子节点，就不能简单的用它的一个子节点代替它。一般找到(a)的右子树中key最小的...
二叉树的删除
cang_ling的博客
01-02 4255
有序二叉树的删除 三种删除模式： 1、删除叶子节点 （1）找到要删除的叶子节点trageNode （2）找到目标结点的父节点parentNode（考虑是否有父节点） （3）找到删除的节点是父节点的左子树还是右子树 （4）根据前面的情况进行删除 左子树：parent.left = null 右子树：parent.right = nul 2、删除只有一个子树的节点 （1）找到要删除的叶子节点trageNode （2）找到目标结点的父节点parentNode（考虑是否有父节点） （3）找到
Java-二叉树-插入、删除、遍历
weixin_30703911的博客
08-25 256
二叉树的具体特性和细节知识点，自行百度，直接上代码。 节点：节点内容、左子孩子、右子孩子、父亲 class Node { private int data; private Node leftChild; private Node rightChild; private Node parent; pub...
二叉树的前中后序查找
weixin_49849351的博客
12-05 505
public class BinaryTreeDemo { public static void main(String[] args) { //创建一颗二叉树 BinaryTree binaryTree = new BinaryTree(); //创建需要的结点 HeroNode root = new HeroNode(1, "宋江"); HeroNode node2 = new HeroNode(2, "吴用"...
java实现二叉树的删除节点操作
qq_39839075的博客
06-12 937
java实现二叉树的删除节点操作
树-排序二叉树删除
a925907195的专栏
09-28 863
相比较节点的添加，平衡二叉树的删除要复杂一些。因为在删除的过程中，你要考虑到不同的情况，针对每一种不同的情况，你要有针对性的反应和调整。所以在代码编写的过程中，我们可以一边写代码，一边写测试用例。编写测试用例不光可以验证我们编写的代码是否正确，还能不断提高我们开发代码的自信心。这样，即使我们在开发过程对代码进行修改或者优化也不会担心害怕。然而看起来编写测试用例是一个繁杂的过程，但是从长期的收益来看
Java实现二叉树算法教程
7. 二叉树的其他操作：除了上述基本操作，二叉树还可以实现其他高级操作，如删除节点、平衡树的实现（例如AVL树或红黑树）、序列化和反序列化等。 通过上述知识点的学习，我们可以了解到二叉树在计算机科学中的基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值