树的遍历--先序/中序/后序--递归/非递归--java

树的遍历

先序/中序/后序遍历（递归函数）

先序/中序/后序遍历（非递归函数）

import java.lang.reflect.AnnotatedElement;
import java.util.ArrayList;
import java.util.List;

import javax.swing.border.EmptyBorder;


public class main8 {

	
	
	public static class TreeNode {
	     int val;
	     TreeNode left;
	     TreeNode right;
	     TreeNode(int x) { val = x; }
	 }
	
	//递归方式
	//先序遍历
	public static void  preordertravel(TreeNode node)
	{
		if(node==null)
			return;
		System.out.print(node.val+" ");
		
		preordertravel(node.left);
		preordertravel(node.right);
		
	}
	//中序遍历
	public static void  middletravel(TreeNode node)
	{
		if(node==null)
			return;
		middletravel(node.left);
		System.out.print(node.val+" ");
		
		middletravel(node.right);
		
		
	}
	//后序遍历
	public static void  behindtravel(TreeNode node)
	{
		if(node==null)
			return;
		behindtravel(node.left);
		behindtravel(node.right);
		System.out.print(node.val+" ");
	}
	
	//非递归方式
	//先序遍历
	//规则：(1)先把头结点放入栈
	//(2)对于新放入栈的节点，出栈并输出，并依次放入右节点，左节点
	//(3)重复（2）操作，直至栈为空
	public static void preordersort2(TreeNode node)
	{
		List<TreeNode> nodes=new ArrayList<TreeNode>();
		nodes.add(node);
		while(nodes.size()!=0)
		{
			TreeNode treeNode=nodes.get(nodes.size()-1);
			System.out.print(treeNode.val+" ");
			
			nodes.remove(nodes.size()-1);
			if(treeNode.right!=null)
			{
				nodes.add(treeNode.right);
			}
			if(treeNode.left!=null)
			{
				nodes.add(treeNode.left);
			}	
		}
		System.out.println();
	}
	//中序遍历
	// 规则：
	//(1) 把头结点放入
	//(2)对于每一个新放入的节点都把它的左节点放入
	//(3)当没有左节点要放入时，就出栈并输出栈顶的节点 并把它的右节点放入 然后对于该节点执行（2）
	public static void middlesort2(TreeNode node)
	{
		List<TreeNode> nodes=new ArrayList<TreeNode>();
		nodes.add(node);
		int n=0;
		while(nodes.size()!=0)
		{
			TreeNode treeNode=nodes.get(nodes.size()-1);
			if(treeNode.left!=null&&n==0)
			{
				nodes.add(treeNode.left);
			}
			else {
				System.out.print(treeNode.val+" ");
				nodes.remove(nodes.size()-1);
				n=1;//注意必须有新右节点放入时才能 继续  放栈顶的左节点
				if(treeNode.right!=null)
				{
					nodes.add(treeNode.right);
					n=0;
				}
			}
		}
		System.out.println();
	}
	
	
// 后序遍历
//	规则：
//	（1）把头结点放入栈 1
//	（2）对于新放入的节点，出栈并放入栈2，在栈1中分别按顺序放入它的左节点和右节点
//	（3）重复步骤2，直至栈1为空
//	 (4)输出栈2的元素
	public static void behindordersort2(TreeNode node)
	{
		List<TreeNode> nodes1=new ArrayList<TreeNode>();
		List<TreeNode> nodes2=new ArrayList<TreeNode>();
		nodes1.add(node);
		while(nodes1.size()!=0)
		{
			TreeNode treeNode=nodes1.get(nodes1.size()-1);
			nodes2.add(treeNode);
			nodes1.remove(nodes1.size()-1);
			if(treeNode.left!=null)
			{
				nodes1.add(treeNode.left);
			}
			if(treeNode.right!=null)
			{
				nodes2.add(treeNode.right);
			}
		}
		while(nodes2.size()!=0)
		{
			System.out.print(nodes2.get(nodes2.size()-1).val+" ");
			nodes2.remove(nodes2.size()-1);
		}
		System.out.println();
	}
	// 非递归方式
	//层次遍历
	//(1)向队列中放入头节点
	//(2)出队一个元素，并将它的左节点和右节点进队
	//(3)重复（2）操作，直至队列为空
	public static void leveltravel(TreeNode node)
	{
		List<TreeNode> nodes=new ArrayList<TreeNode>();
		nodes.add(node);
		while(nodes.size()!=0)
		{
			TreeNode treeNode=nodes.get(0);
			System.out.print(treeNode.val+" ");
			nodes.remove(0);
			if(treeNode.left!=null)
				nodes.add(treeNode.left);
			if(treeNode.right!=null)
				nodes.add(treeNode.right);
		}
		System.out.println();
			
	}
	
	
	
	
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeNode aNode=new TreeNode(1);
		TreeNode bNode=new TreeNode(2);
		TreeNode cNode=new TreeNode(3);
		TreeNode dNode=new TreeNode(4);
		TreeNode eNode=new TreeNode(5);
		aNode.left=bNode;
		aNode.right=cNode;
		bNode.left=dNode;
		bNode.right=eNode;
		
		System.out.println("递归方式：");
		System.out.println("先序遍历：");
		preordertravel(aNode);
		System.out.println();
		System.out.println("中序遍历：");
		middletravel(aNode);
		System.out.println();
		System.out.println("后序遍历：");
		behindtravel(aNode);
		System.out.println();
		
		System.out.println("非递归方式：");
		System.out.println("先序遍历：");
		preordersort2(aNode);
		System.out.println("中序遍历：");
		middlesort2(aNode);
		System.out.println("后序遍历：");
		behindordersort2(aNode);
		
		System.out.println("层次遍历");
		leveltravel(aNode);
		
		

	}
	

}