二叉树最大深度递归版与非递归版算法实现

1.递归的本质是通过栈来保存状态，然后再次调用自己进入新的状态，函数返回的时候回到上次保存的状态。 

所以递归转化为非递归，一般通用方法是通过栈保存当前结果状态。 

2.举个例子：

  二叉树最大深度（递归版）

public static int deep(Tree tree){
     if(tree == null){
       return 0；
    }

  if(tree.getLeft() == null && tree.getRight() == null){
    return 1;
  }  

   int ltree = deep(tree.getLeft());//遍历左子树深度
   int rtree = deep(tree.getRight());//遍历有子树深度

   return ltree > rtree ? ltree+1:rtree+1;//比较左右子树深度，返回打的一边

}

  二叉树最大深度（非递归版）

    public static int deep2(Tree tree){
              if(tree == null){
                     return 0;
              }
              int max = 0;
              Stack<Tree> stacks = new Stack<Tree>();//节点栈
              Stack<Integer> heights = new Stack<Integer>();//保存当前节点深度状态
              heights.push(1);
              stacks.push(tree);
              while (!stacks.isEmpty()) {
                      Tree curTree = stacks.pop();
                      int height = heights.pop();
                     
                      if(curTree.getLeft() != null){
                            heights.push(height+1);//记录节点深度值
                            stacks.push(curTree.getLeft());
                      }
                     
                      if(curTree.getRight() != null){
                            heights.push(height+1);//记录节点深度值
                            stacks.push(curTree.getRight());
                      }
                      if(max < height){
                            max = height;
                      }
              }
              return max;
       }

3.总结. 

     递归容易造成栈溢出，通过非递归版实现，更节省空间。

     递归算法简单，一般很难理解，非递归版代码量多，但易理解。面试时要你写个递归版的实现，不妨可以试试非递归版实现。