二叉树的前序、中序、后序的递归和非递归遍历

前序

    /**
     * 递归先序遍历
     * */
    public void preOrderRecursion(TreeNode node){
        if(node==null) //如果结点为空则返回
            return;
        System.out.print(node.val+" ");//访问根节点
        preOrderRecursion(node.left);//访问左孩子
        preOrderRecursion(node.right);//访问右孩子
    }

 /**
     * 非递归先序遍历二叉树
     * */
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> resultList=new ArrayList<>();
        Stack<TreeNode> treeStack=new Stack<>();
        if(root==null) //如果为空树则返回
            return resultList;
        treeStack.push(root);
        while(!treeStack.isEmpty()){
            TreeNode tempNode=treeStack.pop(); 
            if(tempNode!=null){
                resultList.add(tempNode.val);//访问根节点
                treeStack.push(tempNode.right); //入栈右孩子
                treeStack.push(tempNode.left);//入栈左孩子
            }
        }
        return resultList;
    }

中序

 /**
     * 递归中序遍历
     * */
    public void preOrderRecursion(TreeNode node){
        if(node==null) //如果结点为空则返回
            return;
        preOrderRecursion(node.left);//访问左孩子
        visit(node);//访问根节点
        preOrderRecursion(node.right);//访问右孩子
    }

    /**
     * 非递归中序遍历
     * */
public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> list = new ArrayList<Integer>();

    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode cur = root;

    while(cur!=null || !stack.empty()){
        while(cur!=null){
            stack.add(cur);
            cur = cur.left;
        }
        cur = stack.pop();
        list.add(cur.val);
        cur = cur.right;
    }

    return list;
}

后序

    /**
     * 递归后序遍历
     * */
    public void postOrderNonCur(TreeNode node){
        if(node==null) //如果结点为空则返回
            return;
        preOrderRecursion(node.left);//访问左孩子
        preOrderRecursion(node.right);//访问右孩子              
        System.out.print(node.val+" ");//访问根节点
    }

  /** 非递归实现后序遍历 */  
    protected static void iterativePostorder(Node p) {  
        Node q = p;  
        Stack<Node> stack = new Stack<Node>();  
        while (p != null) {  
            // 左子树入栈  
            for (; p.getLeft() != null; p = p.getLeft())  
                stack.push(p);  
            // 当前节点无右子或右子已经输出  
            while (p != null && (p.getRight() == null || p.getRight() == q)) {  
                visit(p);  
                q = p;// 记录上一个已输出节点  
                if (stack.empty())  
                    return;  
                p = stack.pop();  
            }  
            // 处理右子  
            stack.push(p);  
            p = p.getRight();  
        }  
    } 

层次

import java.util.LinkedList;  
  
public class LevelOrder  
{  
  public void levelIterator(BiTree root)  
  {  
      if(root == null)  
      {  
          return ;  
      }  
      LinkedList<BiTree> queue = new LinkedList<BiTree>();  
      BiTree current = null;  
      queue.offer(root);//将根节点入队  
      while(!queue.isEmpty())  
      {  
          current = queue.poll();//出队队头元素并访问  
          System.out.print(current.val +"-->");  
          if(current.left != null)//如果当前节点的左节点不为空入队  
          {  
              queue.offer(current.left);  
          }  
          if(current.right != null)//如果当前节点的右节点不为空，把右节点入队  
          {  
              queue.offer(current.right);  
          }  
      }       
  }  
}