二叉树遍历的递归与非递归实现（java）

 
package com.Tree;

import java.util.Stack;

public class BinaryTree {
	//定义每棵树的根节点
	private TreeNode root = null;
	//二叉树类的构造函数，即为创建根节点
	public BinaryTree(){
		root = new TreeNode(1, "root(A)");
	}
	/*
	 * 创建一棵根节点为A的二叉树
	 *              A
	 *        B            C
	 *    D        E           F
	 *           G    H     I
	 */
	//建立一个如上图的二叉树
	public void buildBinTree(TreeNode root) {
		TreeNode nodeB= new TreeNode(2, "B");
		TreeNode nodeC= new TreeNode(3, "C");
		TreeNode nodeD= new TreeNode(4, "D");
		TreeNode nodeE= new TreeNode(5, "E");
		TreeNode nodeF= new TreeNode(6, "F");
		TreeNode nodeG= new TreeNode(7, "G");
		TreeNode nodeH= new TreeNode(8, "H");
		TreeNode nodeI= new TreeNode(9, "I");
		root.leftChild=nodeB;
		root.rightChild=nodeC;
		nodeB.leftChild=nodeD;
		nodeB.rightChild=nodeE;
		nodeC.rightChild=nodeF;
		nodeE.leftChild=nodeG;
		nodeE.rightChild=nodeH;
		nodeF.leftChild=nodeI;
	}
	//检查二叉树是否为空
	public boolean isEmpty(){
		return root==null;
	}
	//树的高度
	public int TreeHeight() {
		return height(root);
	}
	private int height(TreeNode root) {
		if (root==null) {
			return 0;
		}
		else{
			int i=height(root.leftChild);
			int j=height(root.rightChild);
			return (i<j)?(j+1):(i+1);
		}
	}
	//节点的个数
	public int TreeSize(){
		return size(root);
	}
	private int size(TreeNode root) {
		if (root==null) {
			return 0;
		}
		else {
			return 1+size(root.leftChild)+size(root.rightChild);
		}
	}
	//二叉树的递归前序遍历（根左右）
	public void preTraversal(TreeNode root) {
		if (root!=null) {
			visit(root);
			preTraversal(root.leftChild);
			preTraversal(root.rightChild);
		}
	}
	//二叉树前序遍历的非递归实现
	public void preOrder(TreeNode root)
	{
		Stack TreeStack = new Stack<>();
		if (root!=null) {
			TreeStack.push(root);
			while(!TreeStack.isEmpty())
			{
				root = TreeStack.pop();
				visit(root);
				if (root.rightChild!=null) {
					TreeStack.push(root.rightChild);
				}
				if (root.leftChild!=null){
					TreeStack.push(root.leftChild);
				}
			}
		}
	}
	//二叉树的中序遍历（左根右）
	public void inTraversal(TreeNode root){
		if (root!=null) {
			inTraversal(root.leftChild);
			visit(root);
			inTraversal(root.rightChild);
		}
	}
	//二叉树中序遍历的非递归实现
	public void inorder(TreeNode root){
		Stack TreeStack = new Stack<>();
		while(root!=null) 
		{
			//中序遍历依次将右子节点、根节点入栈，然后将左子节点赋予根节点，
			//直到找出首先出栈的左子节点
			while(root!=null)
			{
				if (root.rightChild!=null) 
					TreeStack.push(root.rightChild);
				TreeStack.push(root);
				root=root.leftChild;
			}
			//获取栈顶元素
			root = TreeStack.pop();
			//将没有右子节点的全部出栈
			while(!TreeStack.empty()&&root.rightChild==null){
				visit(root);
				root=TreeStack.pop();
			}
			//若有右子节点，则首先输出根节点
			visit(root);
			//若根节点有右子节点，则依次出栈获取跟节点的右子节点
			if (!TreeStack.empty()) {
				root=TreeStack.pop();
			}
			else {
				root=null;
			}
		}
	}
	//二叉树的后续遍历（左右根）
	public void postTraversal(TreeNode root){
		if (root!=null) {
			postTraversal(root.leftChild);
			postTraversal(root.rightChild);
			visit(root);
		}
	}
	//二叉树后序遍历的非递归实现
	public void postorder(TreeNode root){
		//用来记录某节点的右子节点是否已经输出
		TreeNode temp = root;
		Stack TreeStack = new Stack<>();
		while(root!=null){
			//左子树入栈
			for(;root.leftChild!=null;root=root.leftChild){
				TreeStack.push(root);
			}
			//当前节点无右子节点或右子节点已经输出
			while(root!=null&&(root.rightChild==null||root.rightChild==temp)){
				visit(root);
				//记录刚输出的节点
				temp=root;
				if (TreeStack.empty()) {
					return;
				}
				root = TreeStack.pop();
			}
			//处理右子节点
			TreeStack.push(root);
			root=root.rightChild;
		}
	}
	//访问一个节点的函数
	public void visit(TreeNode visitNode) {
		visitNode.isVisited=true;
		System.out.println("--name:"+visitNode.data);
	}
	private class TreeNode{
		private int key = 0;
		private String data = null;
		private boolean isVisited = false;
		
		private TreeNode leftChild = null;
		private TreeNode rightChild = null;
		//无参的构造函数
		public TreeNode(){}
		//有参的构造函数
		public TreeNode(int key,String data){
			this.key=key;
			this.data=data;
		}
	}
	public static void main(String[] args) {
		BinaryTree bTree = new BinaryTree();
		bTree.buildBinTree(bTree.root);
		System.out.println("该树的节点数:"+bTree.size(bTree.root));
		System.out.println("该树的深度为："+bTree.height(bTree.root));
		
		System.out.println("递归实现前序遍历:");
		bTree.preTraversal(bTree.root);
		
		System.out.println("非递归实现前序遍历:");
		bTree.preOrder(bTree.root);
		
		System.out.println("递归实现中序遍历:");
		bTree.inTraversal(bTree.root);
		
		System.out.println("非递归实现中序遍历：");
		bTree.inorder(bTree.root);
		
		System.out.println("递归实现后序遍历:");
		bTree.postTraversal(bTree.root);
		
		System.out.println("非递归实现后序遍历：");
		bTree.postorder(bTree.root);
		
	}	
}
二叉树遍历的递归与非递归实现（java）

猜你喜欢
