数据结构之树-二叉树（Java版本）

/**
* 链接二叉树的结点
*/
package 树.二叉树;

public class BinaryTreeNode {
private Object element;//结点元素
private  BinaryTreeNode leftChild;//左子树
private  BinaryTreeNode rightChild; //右子树

/**
* 无参构造函数
*/
public BinaryTreeNode() {
}

/**
* 指定结点元素的构造函数
* @param theElement
*/
public BinaryTreeNode(Object theElement) {
element = theElement;
}

/**
* 指定结点元素，左孩子，右孩子的构造函数
* @param theElement 结点元素
* @param theleftChild 左孩子
* @param therightChild 右孩子
*/
public BinaryTreeNode(Object theElement, BinaryTreeNode theleftChild,
BinaryTreeNode therightChild) {
element = theElement;
leftChild = theleftChild;
rightChild = therightChild;
}

/**
* 获取当前结点大的左孩子
* @return 当前结点的左孩子
*/
public BinaryTreeNode getLeftChild() {
return leftChild;
}

/**
* 获取当前结点的右孩子
* @return 当前结点的右孩子
*/
public BinaryTreeNode getRightChild() {
return rightChild;
}

/**
* 获取当前结点的元素
* @return 当前结点的元素
*/
public Object getElement() {
return element;
}

/**
* 设置当前结点的左孩子
* @param theLeftChild 当前结点设置后的左孩子
*/
public void setLeftChild(BinaryTreeNode theLeftChild) {
leftChild = theLeftChild;
}

/**
* 设置当前结点 的右孩子
* @param theRightChild 当前结点设置后的右孩子
*/
public void setRightChild(BinaryTreeNode theRightChild) {
rightChild = theRightChild;
}

/**
* 设置当前结点的元素
* @param theElement 当前结点设置后的元素
*/
public void setElement(Object theElement) {
element = theElement;
}

/**
* 打印当前结点元素
*/
public String toString() {
return element.toString();
}

}

/**
* 数据结构学习之二叉树
* @author Sking
*/
package 树.二叉树;

import java.lang.reflect.*;
public interface BinaryTree {//二叉树接口

/**
* 判断二叉树是否为空
* @return 二叉树为空则返回true，否则返回false
*/
public boolean isEmpty();

/**
* 返回二叉树的根
* @return 二叉树的根
*/
public Object root();

/**
* 指定根，左孩子，右孩子创建二叉树
* @param root 根
* @param left 做孩子
* @param right 右孩子
*/
public void makeTree(Object root, Object left, Object right);

/**
* 删除二叉树的左子树并返回
* @return 二叉树的左子树
*/
public BinaryTree removeLeftSubtree();

/**
* 删除二叉树的右子树并返回
* @return 二叉树的右子树
*/
public BinaryTree removeRightSubtree();

/**
* 使用指定的节点访问方法前序遍历二叉树
* @param visit 指定的节点访问方法
*/
public void preOrder(Method visit);

/**
* 使用指定的节点访问方法中序遍历二叉树
* @param visit 指定的节点访问方法
*/
public void inOrder(Method visit);

/**
* 使用指定的节点访问方法后序遍历二叉树
* @param visit 指定的节点访问方法
*/
public void postOrder(Method visit);

/**
* 使用指定的节点访问方法层序遍历二叉树
* @param visit 指定的节点访问方法
*/
public void levelOrder(Method visit);
}

/**
* 二叉树的遍历类，含有前序，后序，中序，层序遍历
* @author Sking
*/
package 树.二叉树;
import 队列.ArrayQueue;
public class BinaryTreeTraversal {
/**
* 访问指定二叉树结点
* @param t 被访问的二叉树结点
*/
public static void visit(BinaryTreeNode t) {
System.out.print(t.getElement() + " ");
}

/**
* 对指定二叉树执行前序遍历
* @param t 被遍历的二叉树根节点
*/
public static void preOrder(BinaryTreeNode t) {
if (t != null) {
visit(t); //访问子树的根节点
preOrder(t.getLeftChild()); //访问左子树
preOrder(t.getRightChild()); //访问右子树
}
}

/**
* 对指定的二叉树执行中序遍历
* @param t 被遍历的二叉树根节点
*/
public static void inOrder(BinaryTreeNode t) {
if (t != null) {
inOrder(t.getLeftChild()); //访问二叉树的左子树
visit(t); //访问根
inOrder(t.getRightChild()); //访问二叉树的右子树
}
}

/**
* 对指定的二叉树执行后序遍历
* @param t 被遍历的二叉树的根节点
*/
public static void postOrder(BinaryTreeNode t) {
if (t != null) {
postOrder(t.getLeftChild()); //访问左子树
postOrder(t.getRightChild()); //访问右子树
visit(t); //访问根
}
}

/**
* 对指定的二叉树指定层序遍历
* 使用辅助队列
* @param t 被遍历的二叉树的根节点
*/
public static void levelOrder(BinaryTreeNode t) {
ArrayQueue q = new ArrayQueue(10);//辅助队列
while (t != null) {
visit(t);//访问根节点
if (t.getLeftChild() != null)
q.put(t.getLeftChild());//左孩子节点入列
if (t.getRightChild() != null)
q.put(t.getRightChild());//右孩子节点入列
t = (BinaryTreeNode) q.get();//取出下一个被访问的节点
}
}
}

/**
* 链接二叉树的实现
* @author Sking
*/
package 树.二叉树.链接二叉树;

import java.lang.reflect.*;

import 树.二叉树.*;
import 队列.ArrayQueue;

public class LinkedBinaryTree implements BinaryTree {
private BinaryTreeNode root;// 二叉树的根节点
static Method visit; // 访问节点的方法
static Object[] visitArgs = new Object[1]; // parameters of visit method
static int count; // counter
static Class<?>[] paramType = { BinaryTreeNode.class };// 访问节点方法的参数类型
static Method theAdd1; // 实现计数器增加的方法
static Method theOutput; // 实现输出节点元素的方法
// method to initialize class data members
static {
try {
Class<LinkedBinaryTree> lbt = LinkedBinaryTree.class;
theAdd1 = lbt.getMethod("add1", paramType);
theOutput = lbt.getMethod("output", paramType);
} catch (Exception e) {
}
// exception not possible
}

// only default constructor available

// class methods
/** visit method that outputs element */
public static void output(BinaryTreeNode t) {
System.out.print(t.getElement() + " ");
}

/** visit method to count nodes */
public static void add1(BinaryTreeNode t) {
count++;
}

/**
* 判断二叉树是否为空
*/
public boolean isEmpty() {
return getRoot() == null;
}

public Object root() {
return (getRoot() == null) ? null : getRoot().getElement();
}

/**
* 返回根节点
*
* @return 二叉树的根节点
*/
public BinaryTreeNode getRoot() {
return root;
}

/**
* 设置二叉树的根节点
*
* @param root
*            设置后的根节点
*/
public void setRoot(BinaryTreeNode root) {
this.root = root;
}

/**
* set this to the tree with the given root and subtrees CAUTION: does not
* clone left and right
*/
public void makeTree(Object root, Object left, Object right) {
this.setRoot(new BinaryTreeNode(root, ((LinkedBinaryTree) left)
.getRoot(), ((LinkedBinaryTree) right).getRoot()));
}

/**
* remove the left subtree
*
* @throws IllegalArgumentException
*             when tree is empty
* @return removed subtree
*/
public BinaryTree removeLeftSubtree() {
if (getRoot() == null)
throw new IllegalArgumentException("tree is empty");

// detach left subtree and save in leftSubtree
LinkedBinaryTree leftSubtree = new LinkedBinaryTree();
leftSubtree.setRoot(getRoot().getLeftChild());
getRoot().setLeftChild(null);
return (BinaryTree) leftSubtree;
}

/**
* remove the right subtree
*
* @throws IllegalArgumentException
*             when tree is empty
* @return removed subtree
*/
public BinaryTree removeRightSubtree() {
if (getRoot() == null)
throw new IllegalArgumentException("tree is empty");

// detach right subtree and save in rightSubtree
LinkedBinaryTree rightSubtree = new LinkedBinaryTree();
rightSubtree.setRoot(getRoot().getRightChild());
getRoot().setRightChild(null);

return (BinaryTree) rightSubtree;
}

/** preorder traversal */
public void preOrder(Method visit) {
LinkedBinaryTree.visit = visit;
thePreOrder(getRoot());
}

/** actual preorder traversal method */
static void thePreOrder(BinaryTreeNode t) {
if (t != null) {
visitArgs[0] = t;
try {
visit.invoke(null, visitArgs);
} // visit tree root
catch (Exception e) {
System.out.println(e);
}
thePreOrder(t.getLeftChild()); // do left subtree
thePreOrder(t.getRightChild()); // do right subtree
}
}

/** inorder traversal */
public void inOrder(Method visit) {
LinkedBinaryTree.visit = visit;
theInOrder(getRoot());
}

/** actual inorder traversal method */
static void theInOrder(BinaryTreeNode t) {
if (t != null) {
theInOrder(t.getLeftChild()); // do left subtree
visitArgs[0] = t;
try {
visit.invoke(null, visitArgs);
} // visit tree root
catch (Exception e) {
System.out.println(e);
}
theInOrder(t.getRightChild()); // do right subtree
}
}

/** postorder traversal */
public void postOrder(Method visit) {
LinkedBinaryTree.visit = visit;
thePostOrder(getRoot());
}

/** actual postorder traversal method */
static void thePostOrder(BinaryTreeNode t) {
if (t != null) {
thePostOrder(t.getLeftChild()); // do left subtree
thePostOrder(t.getRightChild()); // do right subtree
visitArgs[0] = t;
try {
visit.invoke(null, visitArgs);
} // visit tree root
catch (Exception e) {
System.out.println(e);
}
}
}

/** level order traversal */
public void levelOrder(Method visit) {
ArrayQueue q = new ArrayQueue(10);
BinaryTreeNode t = getRoot();
while (t != null) {
visitArgs[0] = t;
try {
visit.invoke(null, visitArgs);
} // visit tree root
catch (Exception e) {
System.out.println(e);
}

// put t's children on queue
if (t.getLeftChild() != null)
q.put(t.getLeftChild());
if (t.getRightChild() != null)
q.put(t.getRightChild());

// get next node to visit
t = (BinaryTreeNode) q.get();
}
}

/** output elements in preorder */
public void preOrderOutput() {
preOrder(theOutput);
}

/** output elements in inorder */
public void inOrderOutput() {
inOrder(theOutput);
}

/** output elements in postorder */
public void postOrderOutput() {
postOrder(theOutput);
}

/** output elements in level order */
public void levelOrderOutput() {
levelOrder(theOutput);
}

/** count number of nodes in tree */
public int size() {
count = 0;
preOrder(theAdd1);
return count;
}

/**
* 返回二叉树的高度
*
* @return 二叉树的高度
*/
public int height() {
return theHeight(getRoot());
}

/**
* 返回以指定结点为根的二叉树的高度
*
* @param t
*            二叉树的根节点
* @return 二叉树的高度
*/
static int theHeight(BinaryTreeNode t) {
if (t == null)
return 0;
int hl = theHeight(t.getLeftChild());
int hr = theHeight(t.getRightChild());
if (hl > hr)
return ++hl;
else
return ++hr;
}
}

/**
* 二叉树问题集锦
* @author Sking
*/
package 树.二叉树.二叉树问题总结;

import 栈.ArrayStack;
import 树.二叉树.*;
import 树.二叉树.链接二叉树.LinkedBinaryTree;
import 队列.ArrayQueue;

public class BinaryTreeQuestion {
/**
* (1) 输出完全括弧化的中序遍历形式
*
* @param t
*            被遍历的二叉树根节点
*/
public static void infix(BinaryTreeNode t) {
if (t != null) {
System.out.print("(");
infix(t.getLeftChild());
System.out.print(t.getElement().toString());
infix(t.getRightChild());
System.out.print(")");
}
}

/**
* (2)确定链接二叉树的高度
*
* @param t
*            指定的二叉树根节点
* @return 二叉树的高度
*/
public static int height(BinaryTreeNode t) {
if (t != null) {
int hLeft = height(t.getLeftChild());
int hRight = height(t.getRightChild());
return Math.max(hLeft, hRight) + 1;
} else
return 0;
}

/**
* (3)确定链接二叉树节点数最多的层，根为第一层
*
* @param t
*            指定二叉树的根节点
* @return 连接二叉树节点最多的层
*/
public static int maxLevel(BinaryTreeNode t) {
if (t == null)
return 0;
int maxLevel = 0;// 当前结点个数对多的层
int maxNodes = 0;// 当前单层最大节点个数
// endOfLevel表示层结束标记
BinaryTreeNode endOfLevel = new BinaryTreeNode();
ArrayQueue q = new ArrayQueue();
q.put(t);
q.put(endOfLevel);// 加入第一层的结束标记
int currentLevel = 1;// currentLevel表示当前层
int numOfNodes = 0;// 当前层的节点个数

while (true) {
BinaryTreeNode p = (BinaryTreeNode) q.get();
if (p == endOfLevel) {// 当前层统计结束
if (numOfNodes > maxNodes) {
maxNodes = numOfNodes;
maxLevel = currentLevel;
} else if (numOfNodes == 0)
return maxLevel;// 底层统计结束
currentLevel++;
numOfNodes = 0;
// 每当统计完一层时，都要为下一层加入标记endOfLevel
// (此时下一层的结点已经全部在队列当中，层序遍历的结果）
q.put(endOfLevel);
} else {// 当前层未统计完毕
numOfNodes++;
if (p.getLeftChild() != null)
q.put(p.getLeftChild());
if (p.getRightChild() != null)
q.put(p.getRightChild());
}
}
}

/*
* (4)使用前序遍历制作二叉树的副本
*/
public static BinaryTreeNode preOrderClone(BinaryTreeNode t) {
if (t != null) {
BinaryTreeNode ct = new BinaryTreeNode(t.getElement());
ct.setLeftChild(preOrderClone(t.getLeftChild()));
ct.setRightChild(preOrderClone(t.getRightChild()));
return ct;
} else
return null;
}

/*
* (5)使用后序遍历制作二叉树的副本
*/
public static BinaryTreeNode postOrderClone(BinaryTreeNode t) {
if (t != null) {
BinaryTreeNode cLeft = postOrderClone(t.getLeftChild());
BinaryTreeNode cRight = postOrderClone(t.getRightChild());
return new BinaryTreeNode(t.getElement(), cLeft, cRight);
} else
return null;
}

/**
* (6)判断结点u是否为结点v的子孙
*
* @param u
*            节点u
* @param v
*            节点v
* @return 如果u是节点v的子孙，则返回true，否则返回false
*/
public static boolean Is_Descendant(BinaryTreeNode u, BinaryTreeNode v) {
if (u == v)
return true;
else {
if (v.getLeftChild() != null)
if (Is_Descendant(u, v.getLeftChild()))
return true;
if (v.getRightChild() != null)
if (Is_Descendant(u, v.getRightChild()))
return true;
}
return false;
}

/**
* (7)判断两棵二叉树是否相似
*
* @param b1
*            第一课二叉树的根节点
* @param b2
*            第二课二叉树的根节点
* @return 如果两棵二叉树相似则返回true，否则false
*/
public boolean Bitree_sim(BinaryTreeNode b1, BinaryTreeNode b2) {
if (b1 == null && b2 == null)
return true;
else if (b1 != null && b2 != null
&& Bitree_sim(b1.getLeftChild(), b2.getLeftChild())
&& Bitree_sim(b1.getRightChild(), b2.getRightChild()))
return true;
else
return false;
}

/**
* (8)中序遍历二叉树的非递归算法
*
* @param t
*            被遍历的二叉树根节点
*/
public static void InOrderTraverse(BinaryTreeNode t) {
ArrayStack stack = new ArrayStack();// 辅助栈
BinaryTreeNode p = t;// 当前考虑子树的根节点
// 当p==null并且stack.empty()为true时退出while循环
while (p != null || !stack.empty()) {
// 沿着左孩子路径循环走到“最左边”
if (p != null) {// 当前子树不为空
stack.push(p);// 当前结点入栈
p = p.getLeftChild();// 获取当前结点的左孩子
} else {// p==null,当前子树为空
p = (BinaryTreeNode) stack.pop();// 出栈
System.out.print(p.getElement().toString() + " ");
p = p.getRightChild();// 获取当前结点的右孩子
}
}
}

/**
* (9)中序遍历二叉树的非递归算法2
*
* @param t
*            被遍历的二叉树根节点
*/
public static void InOrderTraverse2(BinaryTreeNode t) {
ArrayStack stack = new ArrayStack();
BinaryTreeNode p;// 当前考虑节点
stack.push(t);
while (!stack.empty()) {
// 沿着左孩子路径循环走到“最左边”
// 当stack.peek()==null的时候退出while循环，表示到达了“最左边”
while ((p = (BinaryTreeNode) stack.peek()) != null)
stack.push(p.getLeftChild());
p = (BinaryTreeNode) stack.pop();// 弹出null元素
if (!stack.empty()) {
p = (BinaryTreeNode) stack.pop();
System.out.print(p.getElement().toString() + " ");
stack.push(p.getRightChild());
}
}
}

/**
* (10)先序遍历二叉树的非递归算法
*
* @param t
*            被遍历二叉树的根节点
*/
public static void PreOrder_Nonrecursive(BinaryTreeNode t) {
ArrayStack stack = new ArrayStack();// 辅助栈
BinaryTreeNode p;// 当前被考虑节点
stack.push(t);
while (!stack.empty()) {
while ((p = (BinaryTreeNode) stack.peek()) != null) {
// 先打印根节点，再将左孩子入栈
System.out.print(p.getElement().toString() + " ");
stack.push(p.getLeftChild());
}
p = (BinaryTreeNode) stack.pop();// 弹出null元素
if (!stack.empty()) {
p = (BinaryTreeNode) stack.pop();
stack.push(p.getRightChild());
}
}
}

/**
* (11)计算二叉树中叶子结点的数目
*
* @param t
*            指定二叉树
* @return 二叉树的叶子节点个数
*/
public static int LeafCount(BinaryTreeNode t) {
if (t == null)
return 0;
else if (t.getLeftChild() == null && t.getRightChild() == null)
return 1;
else
return LeafCount(t.getLeftChild()) + LeafCount(t.getRightChild());
}

/**
* (12)计算二叉树中以值为x的结点为根的子树深度
*
* @param t
*            指定的二叉树
* @param x
*            值
* @return 如果找到值为x的节点则返回该节点深度，否则返回-1
*/
public static void Get_sub_Depth(BinaryTreeNode t, Object x,int[] depth) {
if (t.getElement() == x) {
depth[0]=Get_Depth(t);
} else {
if (t.getLeftChild() != null)
Get_sub_Depth(t.getLeftChild(), x,depth);
if (t.getRightChild() != null)
Get_sub_Depth(t.getRightChild(), x,depth);
}
}

/**
* (13)辅助方法，用于确定指定二叉树结点的深度 深度是从底层开始向上递增，底层深度为1
*
* @param t
*            指定二叉树节点
* @return 指定二叉树节点的深度
*/
public static int Get_Depth(BinaryTreeNode t) {
if (t == null)
return 0;
else {
int m = Get_Depth(t.getLeftChild());
int n = Get_Depth(t.getRightChild());
return (m > n ? m : n) + 1;
}
}

/*
* (13)后序遍历二叉树的非递归算法，使用栈 为了区别两次进栈的不同处理方法，
* 在堆栈中增加一个mark域，mark=0 表示刚刚访问此结点，mark=1表示左
* 子树处理结束返回，mark=2表示右 子树处理结束返回，每次根据栈顶元素的
* mark域决定执行什么工作。只有 当左右子树都处理完毕后才能对该结点调用打
* 印操作，而且存储mark是在 访问左右子树之前就执行。
*/
class PMType {
BinaryTreeNode ptr;
int mark;

public PMType(BinaryTreeNode ptr, int mark) {
this.ptr = ptr;
this.mark = mark;
}
}

public void PostOrder_Stack(BinaryTreeNode t) {
PMType a;
ArrayStack stack = new ArrayStack();
stack.push(new PMType(t, 0));
while (!stack.empty()) {
a = (PMType) stack.pop();
switch (a.mark) {
case 0:
stack.push(new PMType(a.ptr, 1));
if (a.ptr.getLeftChild() != null)
stack.push(new PMType(a.ptr.getLeftChild(), 0));
break;
case 1:
stack.push(new PMType(a.ptr, 2));
if (a.ptr.getRightChild() != null)
stack.push(new PMType(a.ptr.getRightChild(), 0));
break;
case 2:
System.out.print(a.ptr.getElement().toString() + " ");
}
}
}

/**
* (14)求树节点的子孙总数 为了能用一个统一的计算公式计算子孙数目，
* 当t为空指针的时候，访问设置为-1而不是0
*/
public int DescNum(BinaryTreeNode t) {
if (t == null)
return -1;
else
return (DescNum(t.getLeftChild()) + DescNum(t.getRightChild()) + 2);
}

/**
* (15)判断二叉树是否为完全二叉树 思想：不管当前结点是否有左右孩子，都入列，这样当树是完全二叉树
* 时候，遍历时候得到的是一个连续的不包含空指针的序列，反之则有空指针。 另外可能出现一种情况：队列的最后是连续的空指针，此时也是完全二叉树，
* 这种情况在算法中的表现是每一次循环都只执行到if (btn == null)flag = true;
* 如果之后没有出现非空指针则队列将空，return true，如果之后出现非空指针 算法将执行语句else if (flag) return
* false;
*/
public boolean IsFullBinaryTree(BinaryTreeNode t) {
ArrayQueue queue = new ArrayQueue();
BinaryTreeNode btn;
boolean flag = false;
queue.put(t);
while (!queue.isEmpty()) {
btn = (BinaryTreeNode) queue.get();
if (btn == null)
flag = true;
else if (flag)
return false;
else {
queue.put(btn.getLeftChild());
queue.put(btn.getRightChild());
}
}
return true;
}

/**
* (16)求二叉树中结点p,q的最近共同祖先
*/
boolean found = false;

public BinaryTreeNode Find_Near_Ancient(BinaryTreeNode t, BinaryTreeNode p,
BinaryTreeNode q) {
int i;
BinaryTreeNode[] pathp = new BinaryTreeNode[100];
BinaryTreeNode[] pathq = new BinaryTreeNode[100];
// 将根t到两个结点p，q的路径存放在数组当中
FindPath(t, p, pathp, 0);
found = false;
FindPath(t, q, pathq, 0);
for (i = 0; pathq[i] == pathp[i] && pathp[i] != null; i++);
//当pathq[i]!=pathp[i]或者pathq[i]==pathp[i]&&pathp[i]==null时退出
return pathp[--i];
}

public void FindPath(BinaryTreeNode t, BinaryTreeNode p,
BinaryTreeNode[] path, int i) {
if (t == p) {
found = true;
return;
}
path[i] = t;
if (t.getLeftChild() != null)
FindPath(t.getLeftChild(), p, path, i + 1);
if (t.getRightChild() != null && !found)
FindPath(t.getRightChild(), p, path, i + 1);
if (!found)
path[i] = null;// 回溯
}

/**
* (17)非递归复制二叉树
*/
public BinaryTreeNode Bitree_Copy_Nonrecursive(BinaryTreeNode t,
BinaryTreeNode u) {
BinaryTreeNode q;
BinaryTreeNode p;
ArrayStack stack1 = new ArrayStack();
ArrayStack stack2 = new ArrayStack();
stack1.push(t);
u.setElement(t.getElement());
q = u;
stack2.push(u);
while (!stack1.empty()) {
while ((p = (BinaryTreeNode) stack1.peek()) != null) {
q.setLeftChild(new BinaryTreeNode());
q = q.getLeftChild();
q.setElement(p.getElement());
stack1.push(p.getLeftChild());
stack2.push(q);
}
p = (BinaryTreeNode) stack1.pop();
q = (BinaryTreeNode) stack2.pop();
if (!stack1.empty()) {
p = (BinaryTreeNode) stack1.pop();
q = (BinaryTreeNode) stack2.pop();
q.setRightChild(new BinaryTreeNode());
q = q.getRightChild();
q.setElement(p.getElement());
stack1.push(p.getRightChild());
stack2.push(q);
}
}
return u;
}

/**
* (18)交换所有结点的左右子树
*/
public void Bitree_Revolute(BinaryTreeNode t) {
BinaryTreeNode temp;
temp = t.getLeftChild();
t.setLeftChild(t.getRightChild());
t.setRightChild(temp);
if (t.getLeftChild() != null)
Bitree_Revolute(t.getLeftChild());
if (t.getRightChild() != null)
Bitree_Revolute(t.getRightChild());
}

/**
* (18)删除所有以元素x为根的子树
*/
public void Del_Sub_x(BinaryTreeNode t, Object x) {
if (t.getElement() == x)
Del_Sub(t);
else {
if (t.getLeftChild() != null)
Del_Sub_x(t.getLeftChild(), x);
if (t.getRightChild() != null)
Del_Sub_x(t.getRightChild(), x);
}
}

public void Del_Sub(BinaryTreeNode t) {
if (t.getLeftChild() != null)
Del_Sub(t.getLeftChild());
if (t.getRightChild() != null)
Del_Sub(t.getRightChild());
t = null;// 将其赋值为null表示删除t
}
}