二叉树的遍历

遍历方式：前序遍历、中序遍历、后序遍历和层次遍历

                  （递归、非递归）

代码：（递归方式）

           

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class BinaryTree {

	public static class TreeNode{
		String element;
		TreeNode left;
		TreeNode right;
		
		public TreeNode(String val){
			element=val;
			left=null;
			right=null;
		}
	}
	

	//创建二叉树，按照前序遍历方式输入
	public static TreeNode createBinaryTree(){
		Scanner sc=new Scanner(System.in);
		String element=sc.nextLine();
		
		if(!"null".equals(element)){
			TreeNode node=new TreeNode(element);
			node.left=createBinaryTree();
			node.right=createBinaryTree();
			return node;
		}else{
			return null;
		}
	}
	//前序遍历
	public static void preOrderTraverse(TreeNode root){
		if(root!=null){
			System.out.print(root.element+" ");
			preOrderTraverse(root.left);
			preOrderTraverse(root.right);
		}
	}
	//中序遍历
	public static void inOrderTraverse(TreeNode root){
		if(root!=null){
			inOrderTraverse(root.left);
			System.out.print(root.element+" ");
			inOrderTraverse(root.right);
		}
	}
	//后序遍历
	public static void postOrderTraverse(TreeNode root){
		if(root!=null){
			postOrderTraverse(root.left);
			postOrderTraverse(root.right);
			System.out.print(root.element+" ");
		}
	}
	
	private static Queue
    
    
     
      queue=new LinkedList
     
     
      
      ();
	//层次遍历
	public static void levelTraverse(TreeNode root){
		System.out.print(root.element+" ");
		if(root.left!=null){
		queue.offer(root.left);
		}
		if(root.right!=null){
		queue.offer(root.right);
		}
		
		TreeNode node=queue.poll();
		if(node!=null){
			levelTraverse(node);
		}
		
		
	}
}

     
     
    
    

 

输入：

A
B
null
D
null
null
C
E
null
null
null

输出：

A B D C E
B D A E C
D B E C A
A B C D E

思路：（非递归方式）

前序遍历思路：从栈中弹出栈顶节点，访问输出该节点，如果当前节点有右孩子，则压入栈，如果有左孩子，继续压入栈，只要栈不为空，不断循环迭代

中序遍历思路：如果当前节点有左孩子，则将其左孩子输入，并将节点指向其左孩子，否则将当前节点出栈并输出，如果其有右孩子，则将右孩子入栈，并将当前节点指向右孩子，只要栈不为空，不断循环迭代

后序遍历思路：弹出栈顶节点，如果节点没有左孩子和右孩子，输出该节点，还有一种是该节点的前一输出节点不为空且是其左孩子或右孩子，同样输出该节点，否则的话，将该节点压回栈中，如果该节点有右孩子，压入栈，有左孩子，压入栈，只要栈不为空，不断循环迭代

层次遍历思路：使用一个队列记录要访问下一层的节点，从队列中输出当前节点，如果当前节点有左孩子，加入队列，有右孩子，加入队列，只要队列不为空，不断循环迭代

代码：

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

public class BinaryTree {

	public static class TreeNode{
		String element;
		TreeNode left;
		TreeNode right;
		
		public TreeNode(String val){
			element=val;
			left=null;
			right=null;
		}
	}
	

	
	public static TreeNode createBinaryTree(){
		Scanner sc=new Scanner(System.in);
		String element=sc.nextLine();
		
		if(!"null".equals(element)){
			TreeNode node=new TreeNode(element);
			node.left=createBinaryTree();
			node.right=createBinaryTree();
			return node;
		}else{
			return null;
		}
	}
	
	public static void preOrderTraverse(TreeNode root){
		Stack
    
    
     
      stack=new Stack<>();
		if(root!=null){
		stack.push(root);
		}
		while(!stack.isEmpty()){
			root=stack.pop();
			System.out.print(root.element+" ");
			if(root.right!=null){
				stack.push(root.right);
			}
			if(root.left!=null){
				stack.push(root.left);
			}
		}
	}
	
	public static void inOrderTraverse(TreeNode root){
		Stack
     
     
      
       stack=new Stack<>();
		if(root!=null){
			stack.push(root);
			}
		while(!stack.isEmpty()){
			
			
			if(root.left!=null){
				
				stack.push(root.left);
				root=root.left;
			}else{
				root=stack.pop();
				System.out.print(root.element+" ");
				if(root.right!=null){
				stack.push(root.right);
				root=root.right;
				}
			}	
			
			
		}
	}
	
	public static void postOrderTraverse(TreeNode root){
		Stack
      
      
       
        stack=new Stack<>();
		if(root!=null){
			stack.push(root);
		}
	    TreeNode preNode=null;
		while(!stack.isEmpty()){
			root=stack.pop();
			if((root.left==null&&root.right==null)||
				(preNode!=null&&(preNode==root.left||preNode==root.right))){
				
				System.out.print(root.element+" ");
				preNode=root;
			}else{
			
			 
			 stack.push(root);
			 if(root.right!=null){
				 stack.push(root.right);
			 }
			 if(root.left!=null){
				 stack.push(root.left);
			 }
			}
		}
	}
	
	public static void levelTraverse(TreeNode root){
		Queue
       
       
        
         queue=new LinkedList<>();
		if(root!=null){
		queue.offer(root);
		}
		TreeNode current=null;
		while(!queue.isEmpty()){
			current=queue.poll();
			System.out.print(current.element+" ");
			
			if(current.left!=null){
				queue.offer(current.left);
			}
			
			if(current.right!=null){
				queue.offer(current.right);
			}
			
		}
	}

}

       
       
      
      
     
     
    
    

输入：

A
B
null
D
null
null
C
E
null
null
null

输出：

A B D C E
B D A E C
D B E C A
A B C D E