数据结构之二叉树

二叉树之实现、树的遍历：

package BinaryTreeTest;

import java.util.Stack;

//二叉树
//二叉树的实现
//二叉树的递归遍历--1.前序遍历2.中序遍历3.后序遍历
//二叉数的非递归遍历--1.前序非递归遍历2.中序非递归遍历3.后序非递归遍历

public class binaryTree {
	//二叉树的遍历分为顺序存储和链式存储，其中使用链式存储较好。
	//二叉树的节点数据结构,分为数据域和两个引用域
	public class TreeNode{
		private String data;
		private TreeNode leftChild;
		private TreeNode rightChild;
		public TreeNode(){
			
		}
		public TreeNode(String data){
			this.data = data;
			this.leftChild = null;
			this.rightChild = null;
		}
	}
	
	//二叉树的链式存储
	private TreeNode root = null;
	public binaryTree(){
		root = new TreeNode("rootNode(A)");
	}
	
	public void createBinaryTree(TreeNode root){
		TreeNode newNodeB = new TreeNode("B");  
        TreeNode newNodeC = new TreeNode("C");  
        TreeNode newNodeD = new TreeNode("D");  
        TreeNode newNodeE = new TreeNode("E");  
        TreeNode newNodeF = new TreeNode("F");  
        root.leftChild=newNodeB;  
        root.rightChild=newNodeC;  
        root.leftChild.leftChild=newNodeD;  
        root.leftChild.rightChild=newNodeE;  
        root.rightChild.rightChild=newNodeF; 
	}
	public void visit(TreeNode subTree){
		System.out.println("数据域"+subTree.data);
	}
	
	//判断数是否为空
	public boolean isEmpty(){
		return root==null;
	}
	//树的高度
	public int height(TreeNode root){
		if(root==null){
			return 0;
		}else{
			int i = height(root.leftChild);
			int j = height(root.rightChild);
			return (i<j)?(i+1):(j+1);
		}
	}
	//节点个数
	public int size(TreeNode root){
		if(root==null){
			return 0;
		}else{
			return 1 + size(root.leftChild)
					 + size(root.rightChild);
		}
	}
	//返回双亲节点
	public TreeNode parent(TreeNode element){  
        return (root==null|| root==element)?null:parent(root, element);  
    }  
      
    public TreeNode parent(TreeNode subTree,TreeNode element){  
        if(subTree==null)  
            return null;  
        if(subTree.leftChild==element||subTree.rightChild==element)  
            //返回父结点地址  
            return subTree;  
        TreeNode p;  
        //现在左子树中找，如果左子树中没有找到，才到右子树去找  
        if((p=parent(subTree.leftChild, element))!=null)  
            //递归在左子树中搜索  
            return p;  
        else  
            //递归在右子树中搜索  
            return parent(subTree.rightChild, element);  
    } 
	//返回左子树
    public TreeNode getLeftChildNode(TreeNode element){  
        return (element!=null)?element.leftChild:null;  
    }  
      
	//返回右子树
    public TreeNode getRightChildNode(TreeNode element){  
        return (element!=null)?element.rightChild:null;  
    } 
	//删除节点
	
	//前序遍历
	//先是遍历父节点，然后遍历左子树、右子数
	public void preOrder(TreeNode subTree){
		if(subTree!=null){
			//显示父节点
			visit(subTree);
			preOrder(subTree.leftChild);
			preOrder(subTree.rightChild);
		}
	}
	//中序遍历
	//先是遍历左子树，然后遍历父节点和右子树
	public void inOrder(TreeNode subTree){
		if(subTree!=null){
			inOrder(subTree.leftChild);
			visit(subTree);
			inOrder(subTree.rightChild);
		}
	}
	
	//后序遍历
	//先是遍历左子树、右子树和父节点
	public void postOrder(TreeNode subTree){
		if(subTree!=null){
			postOrder(subTree.leftChild);
			postOrder(subTree.rightChild);
			visit(subTree);
			
		}
	}
	//前序非递归遍历
	public void iterativePreOrder(TreeNode root){
		TreeNode p = root;
		Stack travStack = new Stack();
		if(p!=null){
			travStack.push(p);
			while(!travStack.isEmpty()){
				p = (TreeNode) travStack.pop();
				visit(p);
				if(p.rightChild!=null){
					travStack.push(p.rightChild);
				}
				if(p.leftChild!=null){
					travStack.push(p.leftChild);
				}
			}
		}
	}
	//中序非递归遍历
	public void iterativeInOrder(TreeNode root){
		TreeNode p = root;
		Stack travStack = new Stack();
		while(p!=null){
			while(p!=null){
				if(p.rightChild!=null){
					travStack.push(p.rightChild);
				}
				travStack.push(p);
				p = p.leftChild;
			}
			p = (TreeNode) travStack.pop();
			while(!travStack.isEmpty()&& p.rightChild==null){
				visit(p);
				p = (TreeNode) travStack.pop();
			}
			visit(p);
			if(!travStack.isEmpty())
				p = (TreeNode) travStack.pop();
			else p = null;
		}
	}
	//后序非递归遍历
	public void iterativePostOrder(TreeNode root){
		TreeNode p = root,q = root;
		Stack travStack = new Stack();
		while(p!=null){
			for(;p.leftChild!=null;p = p.leftChild){
				travStack.push(p);
			}
			while(p!=null && (p.rightChild==null || p.rightChild==q)){
				visit(p);
				q = p;
				if(travStack.isEmpty())
					return ;
				p = (TreeNode) travStack.pop();
			}
			travStack.push(p);
			p = p.rightChild;
		}
	}
	//测试
	public static void main(String[] args) {
		binaryTree bt = new binaryTree();
		bt.createBinaryTree(bt.root);  
		//bt.preOrder(bt.root);
		//bt.inOrder(bt.root);
		//bt.postOrder(bt.root);
		//bt.iterativePreOrder(bt.root);
		bt.iterativeInOrder(bt.root);
		//bt.iterativePostOrder(bt.root);
	}
}