【数据拾遗（java描述）】--- 二叉树的基本操作

主要代码

import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;

/**
* 简单的二叉树构造
*
* @author xdsjs
* @param <T>
*
*/
public class BinTree<T> {

private BinNode<T> rootNode;// 根节点

public BinTree() {
}

public BinTree(BinNode<T> rootNode) {
this.rootNode = rootNode;
}

/**
* 得到整棵树的高度
*
* @return
*/
public int getHeight() {
return getHeight(rootNode);
}

/**
* 利用递归得到某一结点的高度
*
* @param binNode
*            目标结点
* @return
*/
public int getHeight(BinNode<T> binNode) {
if (binNode == null)
return 0;
int i = getHeight(binNode.getLeftNode());
int j = getHeight(binNode.getRightNode());
return i < j ? j + 1 : i + 1;
}

/**
* 递归得到整棵树的size(即结点数)
*
* @return
*/
public int getSize() {
return getSize(rootNode);
}

/**
* 得到某一子树的size(即结点数)
*
* @param binNode
* @return
*/
public int getSize(BinNode<T> binNode) {
if (binNode == null)
return 0;
return 1 + getSize(binNode.getLeftNode()) + getSize(binNode.getRightNode());
}

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

/**
* 得到整棵树下某一结点的双亲结点
*
* @param binNode
*            某一结点
* @return
*/
public BinNode<T> getParent(BinNode<T> binNode) {
return (binNode == null || binNode == rootNode) ? null : getParent(rootNode, binNode);
}

/**
* 递归得到某子树下某结点的双亲结点
*
* @param subTree
*            某子树
* @param binNode
*            某结点
* @return
*/
public BinNode<T> getParent(BinNode<T> subTree, BinNode<T> binNode) {
if (subTree == null || binNode == null || subTree == binNode || binNode == rootNode)
return null;
if (subTree.getLeftNode() == binNode || subTree.getRightNode() == binNode)
return subTree;
BinNode<T> b;
if (getParent((b = subTree.getLeftNode()), binNode) != null)
return b;
return getParent(subTree.getRightNode(), binNode);
}

/**
* 得到某一结点的左孩子结点
*
* @param binNode
* @return
*/
public BinNode<T> getLeftBinNode(BinNode<T> binNode) {
return (binNode == null) ? null : binNode.getLeftNode();
}

/**
* 得到某一结点的右孩子结点
*
* @param binNode
* @return
*/
public BinNode<T> getRightBinNode(BinNode<T> binNode) {
return (binNode == null) ? null : binNode.getRightNode();
}

public BinNode<T> getRoot() {
return this.rootNode;
}

/**
* 删除整棵树
*/
public void deleteTree() {
deleteTree(rootNode);
}

/**
* 删除某子树（同时将其左右子树全部删除）
*
* @param binNode
*/
public void deleteTree(BinNode<T> binNode) {
if (binNode == null)
return;
deleteTree(binNode.getLeftNode());
deleteTree(binNode.getRightNode());
binNode = null;
}

/**
* 访问某结点
*
* @param subTree
*/
public void visted(BinNode<T> subTree) {
System.out.println("--name:" + subTree.getData());
}

/**
* 先序遍历（递归形式）
*
* @param subTree
*/
public void preOrderTraverse(BinNode<T> subTree) {
if (subTree == null)
return;
visted(subTree);
preOrderTraverse(subTree.getLeftNode());
preOrderTraverse(subTree.getRightNode());
}

/**
* 中序遍历(递归形式)
*
* @param subTree
*/
public void middleOrderTraverse(BinNode<T> subTree) {
if (subTree == null)
return;
middleOrderTraverse(subTree.getLeftNode());
visted(subTree);
middleOrderTraverse(subTree.getRightNode());
}

/**
* 后序遍历(递归形式)
*
* @param subTree
*/
public void postOrderTraverse(BinNode<T> subTree) {
if (subTree == null)
return;
postOrderTraverse(subTree.getLeftNode());
postOrderTraverse(subTree.getRightNode());
visted(subTree);
}

/**
* 先序遍历（非递归形式,效率更高）
*
* @param subTree
*/
public void nrPreOrderTraverse(BinNode<T> subTree) {
if (subTree == null)
return;
Stack<BinNode<T>> stack = new Stack<>();
while (true) {
while (subTree != null) {
visted(subTree);
stack.push(subTree);
subTree = subTree.getLeftNode();
}
if (stack.isEmpty())
break;
subTree = stack.pop();
subTree = subTree.getRightNode();
}
}

/**
* 中序遍历（非递归形式）
*
* @param subTree
*/
public void nrMiddleOrderTraverse(BinNode<T> subTree) {
if (subTree == null)
return;
Stack<BinNode<T>> stack = new Stack<>();
while (true) {
while (subTree != null) {
stack.push(subTree);
subTree = subTree.getLeftNode();
}
if (stack.isEmpty())
break;
subTree = stack.pop();
visted(subTree);
subTree = subTree.getRightNode();
}
}

/**
* 后序遍历（非递归）
*
* @param subTree
*/
public void nrPostOrderTraverse(BinNode<T> subTree) {
if (subTree == null)
return;
Stack<BinNode<T>> stack = new Stack<>();
BinNode<T> lastNode = null;// 表示最近一次访问的节点
while (true) {
while (subTree != null) {
stack.push(subTree);
subTree = subTree.getLeftNode();
}
if (stack.isEmpty())
break;
subTree = stack.peek();
if (subTree.getRightNode() == null || subTree.getRightNode() == lastNode) {
visted(subTree);
subTree = stack.pop();
lastNode = subTree;
subTree = null;
} else {
subTree = subTree.getRightNode();
}
}
}

/**
* 层次遍历（队列实现）
*
* @param subTree
*/
public void levelTraverse(BinNode<T> subTree) {
if (subTree == null)
return;
Queue<BinNode<T>> queue = new LinkedBlockingQueue<>();
queue.add(subTree);
while (!queue.isEmpty()) {
BinNode<T> binNode = queue.poll();
if (binNode != null) {
visted(binNode);
if (binNode.getLeftNode() != null)
queue.add(binNode.getLeftNode());
if (binNode.getRightNode() != null)
queue.add(binNode.getRightNode());
}
}
}

public static void main(String[] args) {
BinTree<String> binTree = new BinTree<>(new BinNode<String>("A"));
/**
* 创建一棵二叉树
*
* <pre>
*
*           A
*     B          C
*  D     E            F
* </pre>
*
*/
BinNode<String> rootNode = binTree.getRoot();
BinNode<String> nodeB = new BinNode<>("B");
BinNode<String> nodeC = new BinNode<>("C");
BinNode<String> nodeD = new BinNode<>("D");
BinNode<String> nodeE = new BinNode<>("E");
BinNode<String> nodeF = new BinNode<>("F");
rootNode.setLeftNode(nodeB);
rootNode.setRightNode(nodeC);
nodeB.setLeftNode(nodeD);
nodeB.setRightNode(nodeE);
nodeC.setRightNode(nodeF);

System.out.println("*******先序遍历（递归形式）*******");
binTree.preOrderTraverse(rootNode);
System.out.println("*******中序遍历（递归形式）*******");
binTree.middleOrderTraverse(rootNode);
System.out.println("*******后序遍历（递归形式）*******");
binTree.postOrderTraverse(rootNode);
System.out.println("*******先序遍历（非递归形式）*******");
binTree.nrPreOrderTraverse(rootNode);
System.out.println("*******中序遍历（非递归形式）*******");
binTree.nrMiddleOrderTraverse(rootNode);
System.out.println("*******后序遍历（非递归形式）*******");
binTree.nrPostOrderTraverse(rootNode);
System.out.println("*******层次遍历（队列实现）*******");
binTree.levelTraverse(rootNode);
System.out.println("**********我是分割线**********");
System.out.println("该二叉树的高度为：" + binTree.getHeight());
System.out.println("该二叉树的size为：" + binTree.getSize());
}
}

/**
* 表示树节点的类
*
* @author xdsjs
*
* @param <T>
*            结点数据域类型
*/
public class BinNode<T> {

private BinNode<T> leftNode;// 左结点
private BinNode<T> rightNode;// 右结点
private T dataValue;// 数据域

public BinNode() {
}

public BinNode(T dataValue) {
super();
this.dataValue = dataValue;
}

public BinNode(BinNode<T> leftNode, BinNode<T> rightNode, T dataValue) {
this.leftNode = leftNode;
this.rightNode = rightNode;
this.dataValue = dataValue;
}

public BinNode<T> getLeftNode() {
return leftNode;
}

public void setLeftNode(BinNode<T> leftNode) {
this.leftNode = leftNode;
}

public BinNode<T> getRightNode() {
return rightNode;
}

public void setRightNode(BinNode<T> rightNode) {
this.rightNode = rightNode;
}

public T getData() {
return dataValue;
}

public void setData(T data) {
this.dataValue = data;
}

}