二叉树的实现 Java版

package tree;

/**
* 树的操作
*
* @author liangguojun
*
* @param <T>
*            数据类型
*/
public interface SQTree<T> {

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

/**
* 清空树的所有数据元素
*/
public void clear();

/**
* 返回树的深度
*
* @return 返回树的深度
*/
public int getDept();

/**
* 返回节点cur的数据元素
*
* @param cur
*            树中的节点
* @return 返回节点cur的数据元素，若该节点不存在则返回null
*/
public T getValue(TNode<T> cur);

/**
* 返回节点cur的双亲节点
*
* @param cur
*            树中的节点
*
* @return 返回cur的双亲节点，若不存在双亲节点，则返回null
*/
public TNode<T> getParent(TNode<T> cur);

/**
* 返回节点点cur的左孩子节点
*
* @param cur
*            树中的节点
* @return 返回cur节点的左孩子，若不存在左孩子节点则返回null
*/
public TNode<T> getLChild(TNode<T> cur);

/**
* 返回即诶但cur的右孩子节点
*
* @param cur
*            树中的节点
* @return 返回cur节点中的右孩子，若不存在右孩子则返回null
*/
public TNode<T> getRChild(TNode<T> cur);

/**
* 返回cur节点兄弟
*
* @param cur
*            树中的节点
* @return 返回cur节点的兄弟，若不存在则返回null
*/
public TNode<T> getBrother(TNode<T> cur);

/**
* 删除一颗子树，并返回
*
* @param cur
*            子树节点
* @return 返回被删除的子树
*/
public void deleteTree(TNode<T> cur);

/**
* 删除树中的一个节点
*
* @param cur
*            树中的一个节点
* @return 返回被删除节点的数据元素，若不存在这个节点，则返回null
*/
public T deleteNode(TNode<T> cur);
}

package tree;

//前一篇的队列实现
import queue.*;

/**
* 二叉树的实现
* @author liangguojun
*
* @param <T>
*/
public class BiTree<T> implements SQTree<T> {

private TNode<T> root;

public BiTree() {
root = null;
}

public TNode<T> getRoot() {
return root;
}

@Override
public boolean isEmpty() {
if (root == null) {
return true;
}
return false;
}

@Override
public void clear() {
this.root = null;
}

private int getDept(TNode<T> node) {
if (node != null) {
// 递归遍历左右子树的层数
int lc = this.getDept(node.getlChild()) + 1;
int rc = this.getDept(node.getrChild()) + 1;
return lc > rc ? lc : rc;
}
return 0;
}

@Override
public int getDept() {
return getDept(root);
}

@Override
public T getValue(TNode<T> cur) {
if (cur != null) {
return cur.getData();
}
return null;
}

private TNode<T> getParent(TNode<T> root, TNode<T> cur) {
if (root != null) {
if (root.getlChild() == cur | root.getrChild() == cur) {
return root;
}
TNode<T> lt = this.getParent(root.getlChild(), cur);
TNode<T> rt = this.getParent(root.getrChild(), cur);
// 如果左子树返回的父母节点为空则返回右子树的双亲节点，否则返回左子树的父母节点
return lt == null ? rt : lt;
}
return null;
}

@Override
public TNode<T> getParent(TNode<T> cur) {
if (cur != null) {
return this.getParent(root, cur);
}
return null;
}

@Override
public TNode<T> getLChild(TNode<T> cur) {
if (cur != null) {
return cur.getlChild();
}
return null;
}

@Override
public TNode<T> getRChild(TNode<T> cur) {
if (cur != null) {
return cur.getrChild();
}
return null;
}

@Override
public TNode<T> getBrother(TNode<T> cur) {
if (cur != null) {
TNode<T> parent = this.getParent(root, cur);
if (parent != null) {
// 假如双亲节点的左孩子等于cur，则返回双亲的右孩子，否则返回左孩子
return parent.getlChild() == cur ? parent.getrChild() : parent
.getlChild();
}
}
return null;
}

@Override
public void deleteTree(TNode<T> cur) {
if (cur != null) {
// 找到该节点的双亲节点
TNode<T> parent = this.getParent(root, cur);
if (parent.getlChild() == cur) {
parent.setlChild(null);
} else {
parent.setrChild(null);
}
}
return;
}

@Override
public T deleteNode(TNode<T> cur) {
if (cur != null) {
TNode<T> parent = this.getParent(root, cur);
TNode<T> tmp = cur;

TNode<T> rem = null;
if (cur.getrChild() != null)
rem = cur.getrChild();
else if (cur.getlChild() != null)
rem = cur.getlChild();
if (rem != null) {
// 找到该子树的右端点，作为替代节点
while ((tmp.getrChild() != null || tmp.getlChild() != null)
&& (rem.getrChild() != null || rem.getlChild() != null)) {
tmp = rem;
if (rem.getrChild() != null) {
rem = rem.getrChild();

} else if (rem.getlChild() != null)
rem = rem.getlChild();
}

// 删除右端点
if (tmp.getlChild() == rem) {
tmp.setlChild(null);
} else
tmp.setrChild(null);
// 右端点代替被删除的节点
rem.setlChild(cur.getlChild());
rem.setrChild(cur.getrChild());
}
// 修改双亲节点的孩子
if (parent.getlChild() == cur) {
parent.setlChild(rem);

} else {
parent.setrChild(rem);
}

return cur.getData();
}
return null;
}

/**
* 先序遍历二叉树
*
* @param cur
*            二叉树的根节点
*/
private void viewF(TNode<T> cur) {
if (cur != null) {
System.out.print(cur.getData() + " ");
this.viewF(cur.getlChild());
this.viewF(cur.getrChild());
}
}

/**
* 先序遍历二叉树
*/
public void viewFirst() {
System.out.println("先序遍历：");
viewF(root);
System.out.println();
}

/**
* 中序遍历二叉树
*
* @param cur
*            树的根节点
*/
private void viewC(TNode<T> cur) {
if (cur != null) {
this.viewC(cur.getlChild());
System.out.print(cur.getData() + " ");
this.viewC(cur.getrChild());
}
return;
}

/**
* 中序遍历二叉树
*/
public void viewC() {
System.out.println("中序遍历：");
this.viewC(root);
System.out.println();
}

/**
* 后序遍历二叉树
*
* @param cur
*            树的根节点
*/
private void viewL(TNode<T> cur) {
if (cur != null) {
this.viewL(cur.getlChild());
this.viewL(cur.getrChild());
System.out.print(cur.getData() + " ");
}
return;
}

/**
* 后序遍历二叉树
*/
public void viewLast() {
System.out.println("后序遍历：");
this.viewL(root);
System.out.println();
}

/**
* 按层次遍历二叉树
*/
public void cengci() {
LinkedQueue<TNode<T>> treeQueue = new LinkedQueue<>();
treeQueue.enQueue(root);
TNode<T> tmp;
System.out.println("层次遍历：");
while (!treeQueue.isEmpty()) {
// 队列元素出栈
tmp = treeQueue.deQueue();
System.out.print(tmp.getData() + " ");
// 假如左孩子不为空，则左孩子入栈
if (tmp.getlChild() != null)
treeQueue.enQueue(tmp.getlChild());
// 假如右孩子不为空，则右孩子入栈
if (tmp.getrChild() != null)
treeQueue.enQueue(tmp.getrChild());
}
System.out.println();
}

public static BiTree<String> init() {
BiTree<String> bitree = new BiTree<>();
TNode<String> child_f, child_d, child_b, child_c;
child_d = new TNode<String>("D", null, new TNode<String>("G"));
child_b = new TNode<String>("B", child_d, null);
child_f = new TNode<String>("F", new TNode<String>("H"), null);
child_c = new TNode<String>("C", new TNode<String>("E"), child_f);
bitree.root = new TNode<String>("A", child_b, child_c);
return bitree;
}

//测试二叉树
public static void main(String[] args) {
BiTree<String> test = init();
test.cengci();
// test.viewC();
// test.viewFirst();
// test.viewLast();
// test.clear();
System.out.println("二叉树是否为空？：" + test.isEmpty());
System.out.println("二叉树的深度为？：" + test.getDept());
TNode<String> cur = test.getRoot();
// 删除一个节点，寻找右子树的端点代替该节点
// test.deleteNode(cur.getlChild());
// 删除一个子树
// test.deleteTree(cur.getrChild());
// test.cengci();
System.out.println("B的兄弟是？：" + test.getBrother(cur.getrChild()));
}
}