java二叉树的创建,遍历及其他方法

package tree;

import java.util.Stack;

/**二叉树**/
public class BinaryTree {

public static void main(String[] args) {
BinaryTree tree=new BinaryTree();
tree.createBinaryTree();
tree.RLN_Order(tree.root);

tree.noneRecPostOrder(tree.root);
}

private TreeNode root=null;

public BinaryTree(){
root=new TreeNode(1,"rootNode(A)");
}

public  void createBinaryTree(){
TreeNode newNodeB=new TreeNode(2,"B");
TreeNode newNodeC=new TreeNode(3,"C");
TreeNode newNodeD=new TreeNode(4,"D");
TreeNode newNodeE=new TreeNode(5,"E");
TreeNode newNodeF=new TreeNode(6,"F");
TreeNode newNodeG=new TreeNode(7,"G");
TreeNode newNodeH=new TreeNode(8,"H");
TreeNode newNodeI=new TreeNode(9,"I");
TreeNode newNodeJ=new TreeNode(10,"J");

root.left=newNodeB;
root.right=newNodeC;
newNodeB.left=newNodeD;
newNodeB.right=newNodeE;
newNodeC.left=newNodeF;
newNodeC.right=newNodeG;
newNodeF.left=newNodeH;

newNodeG.left=newNodeI;
newNodeG.right=newNodeJ;

}

public boolean isEmpty(){
return root==null;
}

public int height(){
return height(root);
}

public int size(){
return size(root);
}

/**
* 求树的高度
*  int i=(node.left==null)?(0):(height(node.left));
int j=(node.right==null)?(0):(height(node.right));
* **/
private int height(TreeNode node){
if(node==null){
return 0;
}else{
int i=(node.left==null)?(0):(height(node.left));
int j=(node.right==null)?(0):(height(node.right));
return (i<j)?(j+1):(i+1);
}
}

/**求树的大小**/
private int size(TreeNode node){
if(node==null){
return 0;
}else{
return 1+size(node.left)+size(node.right);
}
}

/**返回双亲节点**/
public TreeNode parent(TreeNode element){
return (root==null || root==element)?(null):(parent(root,element));
}

private TreeNode parent(TreeNode subtree,TreeNode element){
if(subtree==null){
return null;
}
if(subtree.left==element || subtree.right==element ){
return subtree;
}
TreeNode p=parent(subtree.left,element);
if(p!=null){
return p;
}else{
return parent(subtree.right,element);
}
}

/**左子节点**/
public TreeNode getLeftChildNode(TreeNode element){
return (element!=null)?(element.left):(null);
}

/**右子节点**/
public TreeNode getRightChildNode(TreeNode element){
return (element!=null)?(element.right):(null);
}

/**通过某个节点摧毁这个节点及其下面的子节点**/
public void destroy(TreeNode node){
if(node !=null){
destroy(node.left);/**删除左边的子节点**/
destroy(node.right);/**删除右边的子节点**/
node=null;/**删除该节点**/
}
}

/**根据某个节点遍历该节点的属性及其子节点**/
public void traverse(TreeNode node){
if(node !=null){
System.out.println("key---->"+node.key+"    name---->"+node.date);
traverse(node.left);
traverse(node.right);
}
}

/**node 表示根(N)     left  表示左(L)    right表示右边(R)**/

/**前根遍历(递归)**/
public void NLR_Order(TreeNode node){
if(node !=null){
visted(node);
NLR_Order(node.left);
NLR_Order(node.right);
}
}

/**中根遍历(递归)**/
public void LNR_Order(TreeNode node){
if(node !=null){
LNR_Order(node.left);
visted(node);
LNR_Order(node.right);
}
}

/**中根遍历(递归)**/
public void RLN_Order(TreeNode node){
if(node !=null){
RLN_Order(node.right);
RLN_Order(node.left);
visted(node);
}
}

/** 前根 (前序) 遍历的非递归实现   **/
public void noneRecPreOrder(TreeNode node){
Stack<TreeNode> s = new Stack<TreeNode>();
s.push(node);
while(!s.isEmpty()) {
TreeNode temp = (TreeNode)s.pop();
visted(temp);
if(temp.right != null) s.push(temp.right);
if(temp.left != null) s.push(temp.left);
}
}

/** 中跟遍历的非递归实现   **/
public void noneRecInOrder(TreeNode node){
Stack<TreeNode> stack=new Stack<TreeNode>();
TreeNode temp=node;
while(temp!=null || !stack.isEmpty()){
if(temp!=null){
stack.push(temp);
temp=temp.left;
}else{
temp=stack.pop();
visted(temp);
temp=temp.right;
}
}
}

/** 后跟遍历的非递归实现   **/
public void noneRecPostOrder(TreeNode p){

}

/**显示该节点的key 和 date**/
public void visted(TreeNode node){
node.isVisted=true;
System.out.println("key------>"+node.key+"    name----->"+node.date);
}

@SuppressWarnings("unused")
private class TreeNode{
private int key;
private String date;
private TreeNode left=null;
private TreeNode right=null;
private boolean isVisted=false;
public TreeNode(int key,String date){
this.key=key;
this.date=date;
}
}

}