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

2019独角兽企业重金招聘Python工程师标准>>>

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;
		}
	}

}

 

转载于:https://my.oschina.net/u/2611757/blog/748941