二叉树的各种遍历算法的递归和非递归实现

二叉树在数据结构中是非常常用的，尤其是关于它的各种遍历算法，经常有关于递归和非递归的实现。下面来一一介绍各种遍历方式。

下面是先序遍历：

先序遍历：首先遍历根节点，然后再遍历左子树，再遍历右子树，那么如果采用递归来遍历，就是首先每一次先输出那个根节点的值，然后接着采用递归方式来遍历。代码如下：

class TreeNode
{
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x)
        {
              val = x;
        }
}
public void preOrder(TreeNode root)
{
         if(root != null)
         {
                System.out.println(root.val);

                if(root.left != null)
                   preOrder(root.left);

                if(root.right != null)
                   preOrder(root.right);
         }
}

如果考虑不采用递归来做，那么就是用Stack来实现。

因为栈有个先进后出的特点，所以在将节点入栈的时候，首先要考虑是先将右子树先入栈，然后再将左子树入栈，因为是出栈的顺序是先进后出，所以这里要特别当心。然后每一次栈顶的元素先出栈，然后顺带着将这个栈顶元素的右子树先入栈，然后是左子树再入栈，一定是这样的顺序。注意，栈底元素在还没出栈之前一定是右子树的根节点。直到第一次它出栈。

public class Solution 

{
    public ArrayList<Integer> preorderTraversal(TreeNode root) 

<span style="font-family: Arial, Helvetica, sans-serif;">        {</span>

        ArrayList<Integer> returnList = new ArrayList<Integer>();
 
        if(root == null)
            return returnList;
 
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
 
        while(!stack.empty()){
            TreeNode n = stack.pop();          //每次先让它出栈
            returnList.add(n.val);
 
            if(n.right != null){
                stack.push(n.right);
            }
            if(n.left != null){
                stack.push(n.left);
            }
 
        }
        return returnList;
    }
}

其次是中序遍历：

首先也是采用递归的方式，就是先遍历左子树，然后遍历根节点，接着遍历右子树。所以代码可以这样写：

class TreeNode 
{
          int val;
          TreeNode left;
          TreeNode right;
          TreeNode(int x)
          {
                   val = x;
          }
}
public void inOrder(TreeNode root)
{
        if(root == null)
              return;
        else if(root != null)
        {

                if(root.left != null)
                   inOrder(root.left);
                System.out.println(root.val);

                if(root.right != null)
                   inOrder(root.right);
         }
}

接下来就是采用非递归的方式来进行中序遍历。非递归来中序遍历一棵二叉树，采用的数据结构还是栈，首先，一直循环将左子树压入栈中，直到那个左子树节点为空，那么现在在栈中的所有节点都是关于左子树的，然后开始将栈中的头结点压出栈。然后看它有木有右子树，因为刚才的头结点肯定是没有左子树的节点，但是根据中序遍历的情况，有可能还有右子树，所以得考虑。然后如果有右子树，那么就将这个人右子树节点压入栈中，然后再次循环，看这个右子树节点是否有左子树，如果有，那么继续循环地压入，直到碰到没有左子树的情况，然后将头结点压出栈，接下来就是重复这样循环实现。其实和递归实现的原理差不多。

class TreeNode
{
          int val;
          TreeNode left;
          TreeNode right;
          TreeNode(int x)
          {
                 val = x;
          }
}
public List<Integer> inOrder(TreeNode root)
{
          List<Integer> list = new ArrayList<Integer>();
          if(root == null)
                return;
          else
          {
                  Stack<Integer> stack = new Stack<Integer>();
                  NodeTree Current = root;
                  while(Current != null || !stack.isEmpty())
                  {
                         while(Current != null)
                         {
                                stack.push(Current.val);
                                Current = Current.left;
                         }
                         if(!stack.isEmpty())
                         {
                                Current = stack.pop();
                                list.add(Current.val);
                                if(Current.right != null)        //考虑左子树的右子树是否存在，如果存在，那么就将其压入栈中
                                       Current = Current.right;
                          }
                    }
              }
              return list;
}

还有一种非递归的方式来中序遍历二叉树，因为上面那种方法来leetcode中发现超时了，所以得换一种方式：

public List<Integer> inOrder(TreeNode root)
{
        List<Integer> list = new ArrayList<Integer>();
        if(root == null)
              return list;
        else
        {
                 Stack<TreeNode> stack = new Stack<TreeNode>();
                 TreeNode Current = root;
                 while(Current != null || !stack.isEmpty())
                 {
                         if(Current != null)
                         {
                                  stack.push(Current);
                                  Current = Current.left;
                          }
                          else
                          {
                                    TreeNode t = stack.pop();
                                    list.add(t.val);
                                    Current = t.right;
                          }
                   }
           }
           return list;
}

接下来是后续遍历：

首先采用递归的方式来实现后续遍历，与先序和中序遍历类似。

public void postOrder(TreeNode root)
{
          if(root == null)
                return;
          else
          {
                 if(root.left != null)
                      postOrder(root.left);
                 if(root.right != null)
                      postOrder(root.right);
                 System.out.println(root.val);
          }
}

然后是非递归实现后续遍历，也是采用栈来实现，就是入栈和出栈顺序上得注意

public void thePostOrderTraversal_Stack(Node root) {   //后序遍历
    Stack<Node> stack = new Stack<Node>();
    Stack<Node> output = new Stack<Node>();//构造一个中间栈来存储逆后序遍历的结果
    Node node = root;
    while (node != null || stack.size() > 0) {
      if (node != null) {
        output.push(node);
        stack.push(node);				
        node = node.getRightNode();
      } else {
        node = stack.pop();				
        node = node.getLeftNode();
        
      }
    }
    while (output.size() > 0) {
      printNode(output.pop());
    }
  }