二叉树删除结点

最新推荐文章于 2025-03-19 23:53:10 发布
原创 最新推荐文章于 2025-03-19 23:53:10 发布 · 693 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

这篇博客探讨了两种删除非叶子节点的方法在二叉树中的实现。方法一是直接删除结点，而方法二是通过替换操作来删除结点。通过示例代码展示了如何在前序、中序和后序遍历中应用这些方法，并在删除节点后重新进行遍历，以验证删除操作的正确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

方法一(delNode):若为非叶子结点将此结点的树直接删除(代码163行)

方法二(delNode1):若为非叶子结点(代码188行)
            若只有一个子结点,让该子节点代替结点
            若结点为a,左子结点为b,右子接点为c,让b结点代表a

package tree;

public class BinaryTreeAPP {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		HeroNode root=new HeroNode(1, "宋江");
		HeroNode node1=new HeroNode(2, "吴用");
		HeroNode node2=new HeroNode(3, "卢俊义");
		HeroNode node3=new HeroNode(4, "林冲");
		HeroNode node4=new HeroNode(5, "关胜");
		root.setLeft(node1);
		root.setRight(node2);
		node2.setRight(node3);
		node2.setLeft(node4);
		BinaryTree binaryTree=new BinaryTree(root);
		System.out.println("删除结点前:");
		System.out.println("前序排序");
		binaryTree.preOrder();
		System.out.println("中序排序");
		binaryTree.midOrder();
		System.out.println("后序排序");
		binaryTree.postOrder();
		binaryTree.delNode1(3);
		System.out.println("删除结点后:");
		System.out.println("前序排序");
		binaryTree.preOrder();
		System.out.println("中序排序");
		binaryTree.midOrder();
		System.out.println("后序排序");
		binaryTree.postOrder();
	}

}

//树
class BinaryTree{
	private HeroNode root;
	public BinaryTree(HeroNode root) {
		this.root=root;
	}
	
	//调用前序遍历
	public void preOrder() {
		if(root!=null) {
			root.preOrder();
		}else {
			System.out.println("根节点为空 ");
		}
	}
	
	//调用中序遍历
	public void midOrder() {
		if(root!=null) {
			root.midOrder();
		}else {
			System.out.println("根节点为空 ");
		}
	}
	
	//调用后序遍历
	public void postOrder() {
		if(root!=null) {
			root.postOrder();
		}else {
			System.out.println("根节点为空 ");
		}
	}
	
	//调用删除结点方法
	public void delNode(int no) {
		if(root!=null) {
			root.delNode(root, no);
		}else {
			System.out.println("根节点为空 ");
		}
	}
	
	//调用删除节点方法一
	public void delNode1(int no) {
		if(root!=null) {
			root.delNode1(root, no);
		}else {
			System.out.println("根节点为空 ");
		}
	}
	
}

//结点
//回溯遍历
class HeroNode{
	private int no;
	private String name;
	private HeroNode left;
	private HeroNode right;
	public HeroNode(int no,String name) {
		this.setNo(no);
		this.setName(name);
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public HeroNode getLeft() {
		return left;
	}
	public void setLeft(HeroNode left) {
		this.left = left;
	}
	public HeroNode getRight() {
		return right;
	}
	public void setRight(HeroNode right) {
		this.right = right;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public void show() {
		System.out.println("HeroNode [no="+no+",name="+name+"]");
	}
	
	//前序遍历
	public void preOrder() {
		this.show();
		if(this.left!=null) {
			this.left.preOrder();
		}
		if(this.right!=null) {
			this.right.preOrder();
		}
	}
	
	//中序遍历
	public void midOrder() {
		if(this.left!=null) {
			this.left.midOrder();
		}
		this.show();
		if(this.right!=null) {
			this.right.midOrder();
		}
	}
	
	//后序遍历
	public void postOrder() {
		if(this.left!=null) {
			this.left.postOrder();
		}
		if(this.right!=null) {
			this.right.postOrder();
		}
		this.show();
	}
	
	//删除结点(若为非叶子结点将此结点的树直接删除)
	public void delNode(HeroNode temp,int flag){
		if(temp.left!=null&&temp.left.no==flag){
			temp.left=null;
			return;
		}
		if(temp.right!=null&&temp.right.no==flag){
			temp.right=null;
			return;
		}
		if(temp.left!=null){
			delNode(temp.left,flag);
		}
		if(temp.right!=null){
			delNode(temp.right,flag);
		}

		System.out.println("未找到此结点");
	}



	//删除结点(若为非叶子结点)
	//若只有一个子结点,让该子节点代替结点
	//若结点为a,左子结点为b,右子接点为c,让b结点代表a
	//node:待删除结点的父节点
	public void delNode1(HeroNode node,int flag){
		if(node.left!=null&&node.left.no==flag){//匹配成功
			HeroNode temp=node.left;//temp承载被删除结点
			if(temp.left==null&&temp.right==null){//叶子结点
				node.left=null;//叶子节点直接删除
			}else if(temp.left!=null&&temp.right!=null){//两个子节点
				temp.left.right=temp.right;//将被删除结点的左子节点的右子节点指向被删除结点子节点的右子节点
				node.left=temp.left;//被删除结点的父节点的左子节点指向被删除节点的左子节点(被删除字节的左子节点取代被删除节点的位置)
			}else if(temp.left!=null&&temp.right==null){//右子结点为空
				node.left=temp.left;
			}else if(temp.right!=null&&temp.left==null){//左子结点为空
				node.left=temp.right;
			}
			return;
		}
		if(node.right!=null&&node.right.no==flag){//匹配成功
			HeroNode temp=node.right;
			if(temp.left==null&&temp.right==null){//叶子结点
				node.right=null;
			}else if(temp.left!=null&&temp.right!=null){//两个子节点
				node.right=temp.left;
				temp.left.left=temp.right;
			}else if(temp.left!=null&&temp.right==null){//右子结点为空
				node.right=temp.left;
			}else if(temp.right!=null&&temp.left==null){//左子结点为空
				node.right=temp.right;
			}
			return;
		}
		if(node.left!=null){
			delNode(node.left,flag);
		}
		if(node.right!=null){
			delNode(node.right,flag);
		}
		System.out.println("未找到该结点");
	}
}

删除前:

 

方法一: 

 

 

 方法二:

 

 

 

数据结构笔记_25 二叉树删除结点
行者常至，为者常成
02-28 301
本节任务： 如果删除的节点是叶子节点，则删除该节点 如果删除的节点是非叶子节点，则删除该子树 测试删除5号叶子节点和3号子树 思路图解： 规定： 如果删除的节点是叶子节点，则删除该节点。 如果删除的节点是非叶子节点，则删除该子树。 把判断root的逻辑写在BinaryTree二叉树的删除方法里，然后递归的逻辑写在HeroNode节点的删除方法里。 思路： 首先处理： 考虑如果树是空树，和如果只有一个root节点，则等价于将二叉树置空。 public void delNode(int no)
二叉树删除节点
xiaowanziddd的博客
02-06 2086
二叉树删除节点 完成删除结点的操作 规定：①如果删除的结点是叶子结点，则删除该结点    ②如果删除的结点是非叶子结点，则删除该子树 思路： 1.考虑如果树是空树root,如果只有一个root结点，则等价将二叉树置空。 2.因为二叉树数单向的，所以判断当前结点的子结点是否需要删除结点，而不能去判断当前结点是不是需要删除的结点。 3.如果当前结点的左子结点不为空，并且左子结点就是要删除的结点，就将this.left = null;并且就返回(结束递归删除) 4.如果当前结点的右子结点不为空，并且右子结点就是要
删除二叉树的某个结点源代码
08-27
这个是删除二叉树某个结点的源代码，可行。
leetcode 450. 删除二叉搜索树中的节点
Head_Hard的博客
09-14 398
给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的key对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。 一般来说，删除节点可分为两个步骤： 首先找到需要删除的节点； 如果找到了，删除它。 说明： 要求算法时间复杂度为O(h)，h 为树的高度。 示例: root = [5,3,6,2,4,null,7] key = 3 ...
数据结构-删除查找二叉树的节点
yuezheyue123的博客
08-03 1147
查找二叉树删除节点，在这里需要在每个节点上添加父节点。这样才能改变节点的左孩子和右孩子的指向的地址。仅仅是设置当前节点为null。仅仅是改变了当前变量的保存的地址。并没有改变其根节点上的节点的索引。 删除节点如果不是叶子节点或是只有一个左子树或右子树的节点，那么很多时候需要移动节点，这样保持查找二叉树的结构。 如果对先序遍历和二叉树转化的算法不熟，可以看博客：https://blog.csdn...
二叉排序树的删除+图解
热门推荐
Frank---7的博客
03-30 5万+
图解 第一种情况 第二种情况 第三种情况 代码实现 package com.atguigu.binarysorttree; import com.sun.javafx.sg.prism.NGImageView; import javafx.scene.transform.Rotate; import java.io.InputStream; import java.util.Timer; /** * @创建人 wdl * @创建时间 2021/3/29 * @描述 */ public
java实现二叉树删除结点
04-17
好的，关于二叉树删除结点，可以通过以下代码实现： ``` // 定义节点类 class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } // 二叉树删除结点方法 public TreeNode ...
java二叉树删除结点代码
11-07
以下是Java中二叉树删除结点的代码实现： ```java public TreeNode deleteNode(TreeNode root, int key) { if (root == null) { return null; } if (key ) { root.left = deleteNode(root.left, key); } else...
孩子兄弟存储的二叉树删除结点的思路？
03-24
对于二叉树删除结点的思路，我们可以采用以下的步骤： 1. 找到要删除的结点，如果要删除的结点是根节点，需要特殊处理。 2. 如果要删除的结点只有一个子树，把它的子树和它的父节点连接起来，删除该结点即可。 3....
二叉树-删除节点
qq_30657195的博客
06-03 594
要求 如果删除的节点是叶子节点，则删除该节点。 如果删除的节点是非叶子节点，则删除树。 测试 删除5号叶子节点和3号树。 代码实现 package chapter18.binarytree object BinaryTreeDemo { def main(args: Array[String]): Unit = { //先使用比较简单的方法，直接关联 val root = new HeroNode(1, "宋江") val hero2 = new HeroNode(2,
二叉树之删除节点
weixin_62938484的博客
03-19 594
1：删除叶子节点。
二叉树~删除节点
qq_45058113的博客
04-14 2222
要求： 1）如果删除的是叶子节点，则删除叶子节点 2）如果删除的是非叶子节点，则删掉整个子树 3）测试，删掉3号和5号节点 思路： 首先考虑： 考虑如果树是空树，如果只有一个root节点，那么等价于将整个二叉树置空 然后进行下面操作 1）因为二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能判断当前这个节点上是不是需要删除的节点 2）如果当前节点的左子节点不为空，且左子节点就是要删除的节点，就将this.left == null;并且返回（结束递归） 3) 如果当
二叉树的删除代码(包含所有情况)
PDyee的博客
01-02 971
二叉树的删除 1、分类讨论 如图 节点可以分为3种类型 0个子树：删除①，先寻找 ①，再寻找①的父节点②，通过父节点②指向空(null)来实现删除①。 1个子树：删除⑦，先寻找 ⑦，再寻找⑦的父节点⑤，让⑤直接指向⑦的左或者右子树来实现删除⑦。 2个子树：删除②，先寻找 ②，找到②右子树的最小值或者左子树的最大值，将②变成那个值，并删除那个值。 2、代码 search通过value值找到目标节点，使用递归的方法查找 public TreeNode search(TreeNode root,Int
关于二叉树的删除节点的想法1
shuyan745294340的博客
03-15 262
对于二叉树的删除节点的操作一般有三种情况 1.后继无人 就是该节点没有左孩子 右孩子 2.后继有右 就是该节点只有一个节点(可以是左孩子 也可以是右孩子) 3.后继有俩 就是该节点有左右孩子 情况1: 删除了该节点 则该节点的状态为空了 一个二叉树已经是有了大小顺序 设置要删除的节点的值为key 如果key的值大于root的值 就直接向右边找 如果不是往左边找 然后查找是否存在相同值得节点...
排序二叉树-删除节点
shengjk1的博客
06-23 1098
前面( https://blog.csdn.net/jsjsjs1789/article/details/106772632 )，我们已经了解了什么是排序二叉树以及排序二叉树的遍历和添加元素，现在我们一起来看一下，排序二叉树是如何删除元素的。 package xmht.datastructuresandalgorithms.datastructure.binarysortTree; /** * @author shengjk1 * @date 2020/6/15 */ public class B
二叉树删除节点，方法一
weixin_44863954的博客
04-21 2797
标题删除的节点拥有左子节点和右子节点，找出deleteNode的左子树的最大节点值（或者右子树的最小值），用最大节点值覆盖要删除节点的值，然后处理删除最大节点值 public void delete(int key) throws Exception { Node current=root; Node parent=null; //找到要删除的节点 while (current.key!=key){ parent=
最完整二叉树删除节点
weixin_41286148的博客
11-26 6876
二叉树删除节点 在自己研究二叉树删除节点时，查网上资料时发现，网上大部分写的都是错的，主要错在当删除节点既存在左子树，又存在右子树时，在中序遍历后获取后继节点后，大部分文章未考虑后继节点存在右子树的情况。 ...
c++二叉树删除结点
最新发布
08-14
<think>我们参考引用[2]和引用[4]中关于二叉树节点删除的方法，特别是引用[2]详细描述了删除节点的三种情况，引用[4]提供了递归实现的代码。 删除节点需要考虑三种情况： 1. 被删除节点是叶子节点（无子节点）：直接删除。 2. 被删除节点只有一个子节点：用其子节点替代。 3. 被删除节点有两个子节点：找到右子树的最小节点（或左子树的最大节点）的值复制到当前节点，然后删除那个最小（或最大）节点（此时该节点最多只有一个子节点，可转化为前两种情况）。 我们将实现一个非递归版本和一个递归版本的删除操作。假设我们的二叉树节点结构如下（参考引用[3]）： ```cpp struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} }; ``` 我们以二叉搜索树（BST）为例，因为二叉搜索树有明确的节点值大小关系，删除时需要保持BST的性质。 非递归删除方法步骤： 1. 首先找到要删除的节点及其父节点（因为需要修改父节点的指针）。 2. 根据节点的子节点情况处理： a. 无子节点：父节点指向该节点的指针置为nullptr。 b. 只有一个子节点：父节点指向该节点的指针指向该节点的子节点。 c. 有两个子节点：找到右子树的最小节点（或左子树的最大节点），记录其值，然后递归删除该最小节点，并将当前节点的值替换为最小节点的值。 递归删除方法（参考引用[4]）： 使用递归可以避免显式记录父节点，通过引用传递节点指针。 我们分别实现这两种方法。 注意：在非递归方法中，如果要删除的是根节点，需要特殊处理（或者使用指向指针的指针）。 下面我们给出代码实现：</think>### C++二叉树节点删除实现详解 在二叉树中删除节点需要处理三种情况，确保删除后仍保持树结构的完整性[^2]。以下是基于二叉搜索树（BST）的节点删除实现方法： #### 节点结构定义 ```cpp struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} }; ``` #### 删除操作实现 ```cpp TreeNode* deleteNode(TreeNode* root, int key) { if (!root) return nullptr; // 空树处理 // 1. 查找目标节点 if (key < root->val) { root->left = deleteNode(root->left, key); } else if (key > root->val) { root->right = deleteNode(root->right, key); } else { // 2. 找到目标节点后的删除逻辑 // 情况1: 无子节点或单子节点 if (!root->left) { TreeNode* temp = root->right; delete root; return temp; } else if (!root->right) { TreeNode* temp = root->left; delete root; return temp; } // 情况2: 双子节点（替换法） TreeNode* successor = root->right; while (successor->left) { successor = successor->left; // 找右子树最小节点 } root->val = successor->val; // 值替换 root->right = deleteNode(root->right, successor->val); // 删除后继节点 } return root; } ``` #### 关键处理逻辑 1. **叶子节点**：直接删除，父节点指针置空 ```cpp // 示例：删除节点5 parent->left = nullptr; // 或 parent->right delete node; ``` 2. **单子节点**：子节点替代被删节点位置 ```cpp // 示例：删除只有左子树的节点 parent->left = node->left; // 孙子变儿子 delete node; ``` 3. **双子节点**（核心难点）： - 找到右子树最小节点（或左子树最大节点） - 复制其值到被删节点 - 递归删除该后继节点 ```cpp // 替换值后删除后继节点 node->val = successor->val; node->right = deleteNode(node->right, successor->val); ``` #### 时间复杂度分析 - 平均情况：$O(\log n)$（平衡二叉树） - 最坏情况：$O(n)$（退化成链表） #### 注意事项 1. 内存管理：删除后及时释放节点内存 2. 平衡性：频繁删除可能破坏BST平衡性，可考虑AVL/红黑树 3. 特殊处理：根节点删除需要更新树根指针 > 示例：删除节点6（双子节点情况） > 1. 找到右子树最小节点7 > 2. 将6的值替换为7 > 3. 在右子树中递归删除原节点7 > > 最终树结构保持二叉搜索树性质[^2][^4]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值