Day04 二叉树的四种遍历(灵活使用Queue、Stack、ArrayList)

转载注明！ https://blog.csdn.net/qq_31842777/article/details/90382639
菜鸟入门，望指正

二叉树有四种遍历方式，即层序遍历、前序遍历、中序遍历、后序遍历。每种遍历都有两种实现方式：递归算法和非递归算法，不同的遍历方式的实现涉及的数据机构不同，主要会用到Queue、Stack、ArrayList。
下面给出各种遍历方式的具体实现及测试。
学习推荐

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

//定义二叉树
public class TreeNode{
	int value=0; //数据域
	TreeNode left=null;// 左子树根节点
	TreeNode right=null;// 右子树根节点
	
	public TreeNode() {}						
	public TreeNode(int value){
		this.value=value;
	}
	public TreeNode(int value,TreeNode left,TreeNode right) {
		this.value=value;
		this.left=left;
		this.right=right;
	}
	
	//层序遍历  使用ArrayList顺序存储数据，使用Queue存取
	public ArrayList<Integer> levelTraversal(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		
		Queue<TreeNode> queue=new LinkedList<TreeNode>();
		queue.offer(root);
		while(!queue.isEmpty()) {
			TreeNode node=queue.poll();
			array.add(node.value);//将遍历到的结点的值添加到array
			if(node.left!=null) {
				queue.offer(node.left);
			}
			if(node.right!=null) {
				queue.offer(node.right);
			}	
		}		
		return array;
	}
	
	//前序遍历递归算法   返回ArrayList对象    
	public ArrayList<Integer> preorderTraversalRec(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		preorderTraversalRec(root,array);
		return array;
	}
	//方法重载
	public void preorderTraversalRec(TreeNode root,ArrayList<Integer> array) {
		if(root==null) {
			return;
		}
		array.add(root.value);
		preorderTraversalRec(root.left,array);
		preorderTraversalRec(root.right,array);
	}
	
	
	//前序遍历非递归算法   ArrayList Stack  先压入右结点，再压入左结点，取出，则为前序遍历
	public ArrayList<Integer> preorderTraversal(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		Stack<TreeNode> stack=new Stack<TreeNode>();
		stack.push(root);
		while(!stack.isEmpty()) {
			TreeNode node=stack.pop();
			array.add(node.value);
			//压入右结点
			if(node.right!=null) {
				stack.push(node.right);
			}
			if(node.left!=null) {
				stack.push(node.left);
			}			
		}
		return array;
	}
	
	
	//中序遍历递归
	public ArrayList<Integer> inorderTraversalRec(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		inorderTraversal(root,array);
		return array;
	}
	public void inorderTraversal(TreeNode root,ArrayList<Integer> array) {
		if(root==null) {
			return;
		}
		inorderTraversal(root.left,array);
		array.add(root.value);
		inorderTraversal(root.right,array);
	}
	
	///中序遍历非递归算法   先存入所有左节点， 
	/**
	 * 拿测试中的二叉树举例，从左到右，从上到下为1，2，4，7，8，见测试
	 * 如 1，2，7  7无左节点，执行if,抛出7，7无右节点，cur为空，不执行while，继续执行if，抛出2
	 * 2有右节点，赋值给cur，cur!=null,执行while,压入8，得到1，8
	 * 8无左节点，执行if,抛出8，8无右节点，cur为空,继续抛出1，此时依次抛出了7，2，8，1
	 * 1有右节点，执行while，压入4，得到4，4无左节点，执行if
	 * 抛出4，得到中序遍历结果7，2，8，1，4
	 */
	public ArrayList<Integer> inorderTraversal(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		Stack<TreeNode> stack=new Stack<TreeNode>();
		TreeNode cur=root;
		while(cur!=null||!stack.isEmpty()) {
			while(cur!=null) {
			stack.add(cur);
			cur=cur.left;
			}
			if(!stack.isEmpty()) {
				cur=stack.pop();
				array.add(cur.value);
				cur=cur.right;
			}
		}
		return array;
	}
	
	//后序遍历递归算法
	public ArrayList<Integer> postorderTraversalRec(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		postorderTraversal(root,array);
		return array;
	}
	public void postorderTraversal(TreeNode root,ArrayList<Integer> array){
		if(root==null) {
			return;
		}
		postorderTraversal(root.left,array);
		postorderTraversal(root.right,array);
		array.add(root.value);
	}
	//后续遍历非递归算法    双栈法     stack1存储结点，先后压入left、right，抛出后依次压入stack2，satck2抛出返回array
	public ArrayList<Integer> postorderTraversal(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		Stack<TreeNode> stack1=new Stack<TreeNode>();
		Stack<TreeNode> stack2=new Stack<TreeNode>();
		stack1.add(root);
		while(!stack1.isEmpty()) {
			TreeNode temp=stack1.pop();
			stack2.push(temp);
			if(temp.left!=null) {
				stack1.push(temp.left);
			}
			if(temp.right!=null) {
				stack1.push(temp.right);
			}			
		}
		while(!stack2.isEmpty()) {//抛出stack2的元素，存入arraylist,并返回
			array.add(stack2.pop().value);
		}
		return array;
	}
	
    //测试
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeNode node1=new TreeNode(2,new TreeNode(7),new TreeNode(8));
        TreeNode bTree=new TreeNode(1,node1,new TreeNode(4));     
        System.out.println("二叉树的层序遍历: "+bTree.levelTraversal(bTree));
        System.out.println("二叉树的前序遍历递归算法: "+bTree.preorderTraversalRec(bTree));
        System.out.println("二叉树的前序遍历非递归算法: "+bTree.preorderTraversal(bTree));
        System.out.println("二叉树的中序遍历递归算法: "+bTree.inorderTraversalRec(bTree));
        System.out.println("二叉树的中序遍历非递归算法: "+bTree.inorderTraversal(bTree));
        System.out.println("二叉树的后序遍历递归算法: "+bTree.postorderTraversalRec(bTree));
        System.out.println("二叉树的后序遍历非递归算法: "+bTree.postorderTraversal(bTree));
	}
}