//删除二叉树中的所有叶子节点
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);
}

定义删除树节点方法

1. 因为二叉树是单向的，所以要判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点.
2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
3. 如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
4. 如果第2和第3步没有删除结点，就需要向左子树进行递归删除
5. 如果第4步也没有删除结点，则应当向右子树进行递归删除.

//递归删除结点
	//1.如果删除的节点是叶子节点，则删除该节点
	//2.如果删除的节点是非叶子节点，则删除该子树
	public void delNode(int no) {
		//2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
		if(this.left != null && this.left.no == no) {
			this.left = null;
			return;
		}
		//3.如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
		if(this.right != null && this.right.no == no) {
			this.right = null;
			return;
		}
		//4.我们就需要向左子树进行递归删除
		if(this.left != null) {
			this.left.delNode(no);
		}
		//5.则应当向右子树进行递归删除
		if(this.right != null) {
			this.right.delNode(no);
		}
	}

定义二叉树中的删除结点方法

public void delNode(int no) {
		if(root != null) {
			//如果只有一个root结点, 这里立即判断root是不是就是要删除结点
			if(root.getNo() == no) {
				root = null;
			} else {
				//递归删除
				root.delNode(no);
			}
		}else{
			System.out.println("空树，不能删除~");
		}
	}

二叉树的删除要考虑三种情况

1.删除的节点是叶子节点

2.删除的节点只有一个子树

3.删除的节点有两个子树

删除的节点是叶子节点

• 找到删除的叶子结点tNode
• 找到目标节点的父节点pNode（考虑是否有父节点）
• 找到删除节点是父节点的左子树还是右子树
• 根据前边情况进行删除
  • 右子树：p.rc=null
  • 左子树：p.lc=null

删除的节点只有一个子树

• 找到删除的叶子结点tNode
• 找到目标节点的父节点pNode（考虑是否有父节点）
• 找到删除节点是父节点的左子树还是右子树
• 确定删除节点是左子树还是右子树
• 根据前边情况进行删除
  • tNode是它父节点的左子树
    • tNode有左子树 ： pNode.lc=tNode.lc
    • tNode有右子树 ： pNode.lc=tNode.rc
  • tNode是是它父节点的右子树
    • tNode有左子树 ： pNode.rc=tNode.lc
    • tNode有右子树 ： pNode.rc=tNode.rc

删除的节点有两个子树

• 找到删除的叶子结点tNode
• 找到目标节点的父节点pNode（考虑是否有父节点）
• 找到删除节点右子树中最小的或找到左子树中最大的
• 将右子树当中最大的值替换掉删除节点的值
• 使删除叶子节点的逻辑，删除最小值

代码实现 

    /**
	 * 找到删除节点
	 * @param node  树
	 * @param value 删除节点值
	 * @return
	 */
	public TreeNode scNode(TreeNode node, int value) {
		if (root == null) {
			return null;
		}

		// 判断node当前所指的节点是不是删除节点
		if (node.value == value) {
			return node;
		} else if (value < node.value) {
			if(node.lc==null) {
				return null;
			}
			return ss(node.lc, value);
		} else {
			if(node.rc==null) {
				return null;
			}
			return ss(node.rc, value);
		}
	}
	
	/**
	 * 找到删除节点父节点
	 * @param node 
	 * @param value 删除节点值
	 * @return
	 */
	public TreeNode scpNode(TreeNode node, int value) {
		if (root == null) {
			return null;
		}
		if((node.lc!=null&&node.lc.value==value)||(node.rc!=null&&node.rc.value==value))                                                                
        {
			return node;
		}else {
			if(node.lc!=null&&value<node.value) {
				return sp(node.lc, value);
			}else if(node.rc!=null&&value>node.value) {
				return sp(node.rc, value);
			}else {
				return null;
			}
		}
	}
    //找到右子树最小值
	public int rMin(TreeNode node) {
		TreeNode Node = node;
		while (Node.lc != null) {
			Node = Node.lc;
		}
		del(root, Node.value);//将右子树最小值节点删除
		return Node.value;//最小值
	}

	public void del(TreeNode node, int value) {
		if (node == null) {
			return;
		}
		TreeNode tNode = ss(node, value);
		if (tNode == null) {
			System.out.println("没有删除的节点");
			return;
		}

		// 整个树只有一个节点
		if (node.lc == null && node.rc == null) {
			root = null;
			return;
		}

		TreeNode pNode = sp(node, value);

		// 删除点是叶子节点
		if (tNode.rc == null && tNode.lc == null) {
			if (pNode.lc != null && pNode.lc.value == tNode.value) {
				pNode.lc = null;
			} else if (pNode.rc != null && pNode.rc.value == tNode.value) {
				pNode.rc = null;
			}

		} else if (tNode.rc != null && tNode.lc != null) {
			// 删除节点有两个子树节点
			int minValue = rMin(tNode.rc);
			tNode.value = minValue;
		} else {// 删除节点只有一个子树节点
			
			//删除节点有左子树
			if (tNode.lc != null) {
				// 删除节点点是他父节点的左子树
				if (pNode.lc.value == tNode.value) {
					pNode.lc = tNode.lc;
				} else {// 删除节点点是他父节点的右子树
					pNode.rc = tNode.lc;
				}
			} else {//删除节点有右子树
				if (pNode.lc.value == tNode.value) {// 删除节点点是他父节点的左子树
					pNode.lc = tNode.rc;
				} else {
					// 删除节点点是他父节点的右子树
					pNode.rc = tNode.rc;
				}
			}
		}
	}
}