递归and非递归，面试二叉树前中序轻轻松拿捏！

前言

大家好，我是bigsai，好久不见，甚是想念！

今天带大家征服二叉树的前中后序遍历，包含递归和非递归方式，学到就是赚到！

很多时候我们需要使用非递归的方式实现二叉树的遍历，非递归枚举相比递归方式的难度要高出一些，效率一般会高一些，并且前中后序枚举的难度呈一个递增的形式，非递归方式的枚举有人停在非递归后序，有人停在非递归中序，有人停在非递归前序(这就有点拉胯了啊兄弟)。

我们回顾递归，它底层其实是维护一个栈，将数据存到栈中，每次抛出栈顶的数据进行处理(也就是递归、dfs的方向化、极端化枚举特征非常明显)，我们驾驭递归的时候更重要的是掌握上下层之间的逻辑关系。

而非递归方式我们除了需要掌握上下层的逻辑关系之外，要手动的处理各种条件变更的细节， 递归是一个一来一回的过程，如果我们的逻辑只是在单趟的来或者回中还好，有时候甚至要自己维护来和回的状态，所以逻辑上难度还是比较大的。

二叉树的前序遍历

二叉树的前序遍历是最简单的，其枚举方式就是一个最简单的dfs，学会了二叉树的前序遍历，那么后面入门dfs就容易很多。

二叉树的前序遍历的枚举规则为：根结点 ---> 左子树 ---> 右子树，也就是给定一棵树，输出操作当前节点，然后枚举左子树(左子树依然按照根左右的顺序进行)，最后枚举右子树(右子树也按照根左右的顺序进行)，这样得到的一个枚举序列就是二叉树的前序遍历序列(也叫先序)。

前序遍历在二叉树树的顺序可以看下图(红色箭头指向的表示需要访问的，可以看出从父节点枚举下来第一次就要被访问)。

在具体实现的方式上，有递归方式和非递归方式实现。

递归

递归方式实现的二叉树前序遍历很简单，递归我们只需要考虑初始情况、结束边界、中间正常点逻辑。

初始情况：从root根节点开始枚举，函数执行传入root根节点作为参数。

结束边界：节点的左(或右)子节点为null那么就停止对应节点的递归执行。

正常点逻辑：先处理当前点(存储或输出)，递归调用枚举左子树(如果不为null),递归调用枚举右子树(如果不为null)。

刚好力扣144二叉树的前序遍历可以尝试ac：

class Solution {
    List<Integer>value=new ArrayList();
    public List<Integer> preorderTraversal(TreeNode root) {
        qianxu(root);
        return value;
    }
    private void qianxu(TreeNode node) {
        if(node==null)
            return;
        value.add(node.val);
        qianxu(node.left);
        qianxu(node.right);
    }
}

非递归

非递归的前序还是非常简单的，前序遍历的规则是：根节点，左节点，右节点。但是根左方向一直下去，手动枚举又没有递归回的过程，一直下去我们怎么找到回来时候的右几点呢？

用栈将路过的节点先存储，第一次枚举节点输出储存然后放入栈中，第二次就是被抛出时候枚举其右侧节点。

它的规则大致为：

1. 一直访问当前节点并用栈存储，节点指向左节点，直到左孩子为null。

2. 抛出栈顶不访问。如果有右节点，访问其右节点重复步骤1，如有没右节点，继续重复步骤2抛出。

这样的一个逻辑，就会从根出发一直先往左访问，访问结束根、左之后再访问右节点(子树)，得到一个完成的前序遍历的序列。

具体实现的代码为：

class Solution {
  public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer>value=new ArrayList();
    Stack<TreeNode> q1 = new Stack();    
        while(!q1.isEmpty()||root!=null)
        {
            while (root!=null) {
                value.add(root.val);
                q1.push(root);                
                root=root.left;
            }
            root=q1.pop();//抛出
            root=root.right;//准备访问其右节点

        }
        return value;
    }
}

二叉树的中序遍历

二叉树的中序遍历出现的频率还是蛮高的，如果是二叉排序树相关问题还是蛮多的，你要知道二叉排序树的中序遍历是一个有序的序列，如果求二叉排序树的topk问题，非递归中序那效率是非常高的。

中序遍历在二叉树树的顺序可以看下图(红色箭头指向的表示需要访问的，可以看出如果子树为null，那肯定要访问，否则就是从左子树回来的时候才访问这个节点)。

递归方式

递归方式实现很简单，其逻辑和前序递归相似的，力扣94刚好有二叉树中序遍历,这里我直接放代码：

class Solution {
   public List<Integer> inorderTraversal(TreeNode root) {
      List<Integer>value=new ArrayList<Integer>();
      zhongxu(root,value);
      return value;
  }
     private void zhongxu(TreeNode root, List<Integer> value) {
         if(root==null)
             return;
         zhongxu(root.left, value);
         value.add(root.val);
         zhongxu(root.right, value);

    }
}

非递归方式

非递归的中序和前序是非常相似的，前序遍历的规则是：根节点，左节点，右节点。中序遍历的顺序是左节点，根节点，右节点 ，在前序中先根后左其实是有点覆盖的关系(这个左就是下一个跟)，在其非递归枚举实现上我们访问右节点时候是先抛出父节点不访问，直接访问父节点的右节点，如果抛出父节点访问这个父节点，其实它就是一个中间顺序的节点。

它的规则大致为：

1. 枚举当前节点(不存储输出)并用栈存储，节点指向左节点，直到左孩子为null。

2. 抛出栈顶访问。如果有右节点，访问其右节点重复步骤1，如有没右节点，继续重复步骤2抛出。

这样的一个逻辑，就会形成一个中序序列，因为叶子节点的左右都为null，这样的规则依然满足中序。

实现代码为：

class Solution {
   public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer>value=new ArrayList<Integer>();
    Stack<TreeNode> q1 = new Stack();    
    while(!q1.isEmpty()||root!=null)
    {
        while (root!=null) {
            q1.push(root);                
            root=root.left;
        }
        root=q1.pop();//抛出
        value.add(root.val);
        root=root.right;//准备访问其右节点

    }
    return value;
  }
}

二叉树的后序遍历

二叉树的后序遍历非递归方式实现起来难度最大的，能够手写非递归后序，一定能亮瞎面试官的眼！

后序遍历在二叉树树的顺序可以看下图(红色箭头指向的表示需要访问的，可以看出如果子树为null，那肯定要访问，否则就是从右子树回来的时候才访问这个节点)。

递归

二叉树递归方式后序遍历很简单，跟前序中序的逻辑一样，在力扣145有后序的code测试大家可以自己尝试一下。

这里直接放我写的后序递归方式：

class Solution {
    List<Integer>value=new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        houxu(root);
        return value;
    }
    private void houxu(TreeNode root) {
        if(root==null)
            return;
        houxu(root.left);
        houxu(root.right);//右子树回来
        value.add(root.val);
    }
}

非递归

非递归的后序就稍微难一点了，大家可以回顾一下二叉树的前序和中序遍历，其实都是只用一个栈直接抛出就可以找到右节点，抛出后栈就空了，但是这个后序遍历的顺序是 左子树 ---> 右子树 --->根节点，也就是处理完右访问。所以从逻辑结构上和前序、中序的非递归实现方式有一些略有不同。