二叉树前序，中序，后序递归和非递归实现

TreeNode定义

public class TreeNode {
    public TreeNode left;
    public TreeNode right;
    public int val;
    
    public TreeNode(int val) {
        this.val = val;
    }
    
    /**
     * 搞一棵二叉树出来
     *                     1
     *                    /  
     *                   2    3
     *                   / 
     *                  4 5  6
     * @return
     */
    public static TreeNode createTree(){
        TreeNode root = new TreeNode(1);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(3);
        TreeNode node3 = new TreeNode(4);
        TreeNode node4 = new TreeNode(5);
        TreeNode node5 = new TreeNode(6);
        
        root.left = node1;
        root.right = node2;
        
        node1.right = node3;
        node2.left = node4;
        node2.right = node5;
        
        return root;
    }
}

---------------------------------------------我是分割线，前序遍历---------------------------------------

/**
 * 前序遍历非递归实现
 * @author GXF
 *
 */
public class PreOrderTreeByNoRec {

    public static void main(String[] args) {
        PreOrderTreeByNoRec preOrderTreeByNoRec = new PreOrderTreeByNoRec();
        TreeNode root = TreeNode.createTree();
        preOrderTreeByNoRec.preOrderByRecursive(root);
        System.out.println();
        preOrderTreeByNoRec.preOrderByNoRec(root);

    }
    
    /**
     * 前序遍历二叉树,非递归实现
     * @param root
     */
    public void preOrderByNoRec(TreeNode root){
        if(root == null)
            return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        System.out.print(root.val + " ");
        stack.push(root);
        
        TreeNode curPoint = root.left;
        
        while(!stack.isEmpty() || curPoint != null){
            if(curPoint != null){
                System.out.print(curPoint.val + " ");
                stack.push(curPoint);
                curPoint = curPoint.left;
            }//if
            
            curPoint = stack.pop().right;
        }
        
        System.out.println();
        
    }
    
    /**
     * 前序遍历递归实现
     * @param root
     */
    public void preOrderByRecursive(TreeNode root){
        if(root != null){
            System.out.print(root.val + " ");
            preOrderByRecursive(root.left);
            preOrderByRecursive(root.right);
        }
        
    
    }
    
    

}

---------------------------------------------我是分割线，中序遍历---------------------------------------

import java.util.Stack;

/**
 * 中序遍历的非递归实现
 * @author GXF
 *
 */
public class InorderTreeByNoRecursive {

    public static void main(String[] args) {
        InorderTreeByNoRecursive inorderTreeByNoRecursive = new InorderTreeByNoRecursive();
        TreeNode root = TreeNode.createTree();
        
        inorderTreeByNoRecursive.inorderByRecursive(root);
        System.out.println();
        inorderTreeByNoRecursive.inorderByNoRecursive(root);
    }
    
    /**
     * 中序遍历递归实现
     */
    public void inorderByRecursive(TreeNode root){
        if(root != null){
            inorderByRecursive(root.left);
            System.out.print(root.val + " ");
            inorderByRecursive(root.right);
        }
    }
    
    /**
     * 中序遍历非递归实现
     * @param root
     */
    public void inorderByNoRecursive(TreeNode root){
        if(root == null)
            return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        TreeNode curPoint = root.left;
        //开始中序遍历
        while(curPoint != null || !stack.isEmpty()){
            while(curPoint != null){
                stack.push(curPoint);
                curPoint = curPoint.left;
            }//while
            
            //访问根结点
            curPoint = stack.pop();
            System.out.print(curPoint.val + " ");
            curPoint = curPoint.right;
        }
    }

}

---------------------------------------------我是分割线，后序遍历---------------------------------------

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class PostorderNoRecurvise {

    public static void main(String[] args) {
        TreeNode root = TreeNode.createTree();
        
        PostorderNoRecurvise postorderNoRecurvise = new PostorderNoRecurvise();
        postorderNoRecurvise.postorderByRecursive(root);
        System.out.println();
        postorderNoRecurvise.postorderByNoRecurvise(root);
    }
    
    /**
     * 递归进行后序遍历
     * @param root
     */
    public void postorderByRecursive(TreeNode root){
        if(root != null){
            postorderByRecursive(root.left);
            postorderByRecursive(root.right);
            System.out.print(root.val + " ");
        }
    }
    
    /**
     * 后序遍历非递归实现
     * @param root
     */
    public void postorderByNoRecurvise(TreeNode root){
        if(root == null)
            return;
        //记录结点是否被访问过
        Map<TreeNode, Boolean> visited = new HashMap<TreeNode, Boolean>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        TreeNode curPoint = root.left;
        while(curPoint != null)
        {
            stack.push(curPoint);
            curPoint = curPoint.left;
        }
        while(!stack.isEmpty()){
            curPoint = stack.peek();
            if(curPoint.right == null || visited.get(curPoint.right) != null){
                curPoint = stack.pop();
                System.out.print(curPoint.val + " ");
                visited.put(curPoint, true);
            }
            else{
                curPoint = curPoint.right;
                while(curPoint != null){
                    stack.push(curPoint);
                    curPoint = curPoint.left;
                }
            }
        }
    }

}

后序遍历需要额外空间保存已经访问过的节点

---------------------------------------------我是分割线，层序遍历---------------------------------------

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

/**
 * 二叉树层序遍历
 * @author GXF
 *
 */
public class LevelTravel {

    public static void main(String[] args) {
        TreeNode root = TreeNode.createTree();
        
        LevelTravel levelTravel = new LevelTravel();
        levelTravel.levelTravel(root);
    }
    
    /**
     * 二叉树层序遍历11
     * @param root
     */
    public void levelTravel(TreeNode root){
        if(root == null)
            return;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            root = queue.poll();
            System.out.print(root.val + " ");
            if(root.left != null)
                queue.add(root.left);
            if(root.right != null)
                queue.add(root.right);
        }
    }
}