二叉树的遍历（先序、中序、后序、层次）

二叉树节点访问时，都是将即将被访问的节点视为根节点的

假设二叉树的节点定义如下：

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;
    }
}

递归方式遍历二叉树
先序遍历

	/**********************
	 * 二叉树的先序遍历算法 -----递归形式
	 * @param root 二叉树的根节点
	 */
	public static void preorderTraversalByRecu(TreeNode root)
	{
		//当前根节点为空 直接返回
		if(root==null)
		{
			return;
		}
		//读取根节点
		System.out.print(root.val);
		//读取左右孩子节点
		preorderTraversalByRecu(root.left);
		preorderTraversalByRecu(root.right);
	}

中序遍历

	/**************************
	 * 二叉树的中序遍历算法------递归形式
	 * @param root 二叉树的根节点
	 */
	public static void inorderTraversalByRecu(TreeNode root)
	{
		//当前根节点为空 直接返回
		if(root==null)
		{
			return;
		}
		//读取左孩子节点
		inorderTraversalByRecu(root.left);
		//读取根节点
		System.out.print(root.val);
		//读取左右孩子节点
		inorderTraversalByRecu(root.right);
	}

后序遍历

	/**************************
	 * 二叉树的后序遍历算法------递归形式
	 * @param root 二叉树的根节点
	 */
	public static void postorderTraversalByRecu(TreeNode root)
	{
		//当前根节点为空 直接返回
		if(root==null)
		{
			return;
		}
		//读取左孩子节点
		postorderTraversalByRecu(root.left);
		//读取左右孩子节点
		postorderTraversalByRecu(root.right);
		//读取根节点
		System.out.print(root.val);
	}

非递归方式遍历二叉树
先序遍历

/**********************
	 * 二叉树的先序遍历算法------非递归形式
	 * @param root 二叉树的根节点
	 */
	public static void preorderTraversal(TreeNode root)
	{
		//当前根节点为空 直接返回
		if(root==null)
		{
			return;
		}
		Stack<TreeNode> stack=new Stack<>();//建立辅助栈
		stack.push(root);//将根节点入栈
		
		//当栈不为空时
		while(!stack.isEmpty())
		{
			//弹出一个栈中节点 即先读取根节点
			TreeNode node=stack.pop();
			System.out.print(node.val);//取根节点值
			
			//判断根节点左右孩子节点是否存在 将左右孩子压栈
			//首先判断右孩子  因为先压栈的后出栈
			if(node.right!=null) stack.push(node.right);
			if(node.left!=null) stack.push(node.left);
		}
	}

中序遍历

/********************
	 * 二叉树的中序遍历算法------非递归形式
	 * @param root 二叉树的根节点
	 */
	public static void inorderTraversal(TreeNode root)
	{
		//当前根节点为空 直接返回
		if(root==null)
		{
			return;
		}
		Stack<TreeNode> stack=new Stack<>();//建立辅助栈
		stack.push(root);//将根节点入栈
		TreeNode leftNode=root.left;//根节点的左孩子节点
		
		//左孩子节点或者栈不为空时 循环
		while(leftNode!=null||!stack.isEmpty())
		{
			//如果左孩子节点不为空 说明还没遍历到当前情况最左边的孩子 继续探索左孩子节点
			if(leftNode!=null)
			{
				//将当前节点压栈 左孩子节点指向当前节点的左孩子节点
				stack.push(leftNode);
				leftNode=leftNode.left;
			}
			//如果左孩子节点已经为空 则上一个元素已经是当前最左边的孩子了
			else {
				//从栈中弹出一个节点并访问 
				TreeNode node=stack.pop();  
				System.out.print(node.val);
				
				//访问当前节点的右孩子节点	
				leftNode=node.right;
			}
		}
	}

后序遍历

/**********************
	 * 二叉树的后序遍历算法------非递归形式
	 * @param root 二叉树的根节点
	 */
	public static void postorderTraversal(TreeNode root)
	{
		//当前根节点为空 直接返回
		if(root==null)
		{
			return;
		}
		Stack<TreeNode> stack=new Stack<>();//建立辅助栈
		boolean flag=true;//辅助变量表示当前结点的左孩子节点是否被访问(为空等同于已访问)
		TreeNode curNode=root;//当前访问的变量
		
		do//栈非空时  循环
		{
			//将所有的最左节点入栈
			while(curNode!=null)
			{
				stack.push(curNode);
				curNode=curNode.left;
			}
			//此时 辅助变量应该设置为true
			flag=true;
			
			TreeNode preNode=null;//指向刚刚访问过的节点
			while((!stack.isEmpty())&&flag)
			{
				curNode=stack.peek();//当前栈顶元素
				if(curNode.right==preNode)//当前节点的右孩子为空 或者已经被访问过
				{
					//栈顶节点出栈 访问 
					System.out.print(stack.pop().val);//即curNode
					preNode=curNode;
				}
				else//否则 处理右孩子节点 
				{
					curNode=curNode.right;
					flag=false;
				}
			}
		}while(!stack.isEmpty());
	}

后序遍历II

/********************
	 * 首先思考一个问题  先序遍历和后序遍历的顺序是什么？
	 * 先序遍历：根左右    后序遍历:左右根  两者之间有联系吗 
	 * 看完了先序遍历的算法(非递归) 是不是比较简单？
	 * 那么能否修改一下先序遍历的算法 使之也能产生后序遍历的序列呢？
	 * 先序遍历肯定是不会改变根节点遍历顺序的  但如果改变一下左右子树的遍历顺序 会怎么样呢？
	 * 节点遍历顺序变成了 根右左 ，正好是后序遍历的逆序
	 * 而这样的修改不难实现 只需要修改一下先序遍历中左右孩子节点入栈的顺序就可以了
	 * 之后将先序结果逆序 便是后序遍历的结果
	 * 二叉树的后序遍历算法------非递归形式II
	 * @param root 二叉树的根节点
	 */
	public static void postorderTraversalII(TreeNode root)
	{
		//当前根节点为空 直接返回
		if(root==null)
		{
			return;
		}
		Stack<TreeNode> stack=new Stack<>();//建立辅助栈
		stack.push(root);//将根节点入栈
		//逆序的结果集 弹出时序列正好反过来 
		Stack<TreeNode> reverseResult=new Stack<>();//只用于存储
		//栈非空时 遍历
		while(!stack.isEmpty())
		{
			//栈中弹出一个节点
			TreeNode node=stack.pop();
			//暂时不访问根节点 将其放入结果栈中
			reverseResult.push(node);
			
			//判断根节点左右孩子节点是否存在 将左右孩子压栈
			//改变判断顺序后 先判断左孩子
			if(node.left!=null) stack.push(node.left);
			if(node.right!=null) stack.push(node.right);
		}
		//现在  将逆序结果集中的结果输出
		//栈的输出就是逆序形式
		while(!reverseResult.isEmpty())
		{
			//栈中弹出结果输出
			System.out.print(reverseResult.pop().val);
		}
	} 

层次遍历

	/*********************
	 * 二叉树的层次遍历 （广度遍历） 
	 * @param root 二叉树的根节点
	 */
	public static void levelTraversal(TreeNode root)
	{
		//当前根节点为空 直接返回
		if(root==null)
		{
			return;
		}
		//使用辅助队列记录未访问过的节点
		Queue<TreeNode> queue=new LinkedList<TreeNode>();
		queue.offer(root);//头结点入栈
		
		//队列非空时，循环
		while(!queue.isEmpty())
		{
			//弹出一个节点 并访问
			TreeNode node=queue.poll();
			System.out.print(node.val);
			
			//判断访问节点的左右孩子节点 先左后右 先进先出
			if(node.left!=null) queue.offer(node.left);
			if(node.right!=null) queue.offer(node.right);
		}
	}