二叉树的前序遍历的递归实现与非递归实现

概念

    二叉树的前序遍历可以称为前根序遍历，遍历的顺序依次为：每个（子）树的根节点->左子节点->右子节点

    

举例说明

    该图的前序遍历的结果为：ABDECF

    

前序遍历非递归实现思路步骤讲解：

    对于任意结点p（当前遍历的结点）：

      1.先输出该节点，然后存放到栈中，执行：p = p->left;并判断p是否为空

      2.p不为空（即之前结点的左子节点不为空）时，执行1

      3.p为空时，从栈中pop当前栈顶元素，不输出，将p赋值给该元素的right右子节点，并判断p是否为空

      4.p不为空（即之前结点的右子节点不为空）时，执行1

      5.p为空时，继续执行3操作

      6.当p为空并且stack栈也为空的时候，循环结束，二叉树的前序遍历也就已经被打印出来了

    

前序遍历非递归实现详细过程

    首先，从根节点A开始，根据操作1），输出A，并将其入栈，由于A的左孩子不为空，根据操作2），将B置为当前节点，再根据操作1），将B输出，并将其入栈，由于B的左孩子也不为空，根据操作2），将D置为当前节点，再根据操作1），输出D，并将其入栈，此时输出序列为ABD；

    由于D的左孩子为空，根据操作3），将栈顶节点D出栈，但不输出，并将其右孩子置为当前节点；

    由于D的右孩子为空，根据操作5），继续将栈顶节点B出栈，但不输出，并将其右孩子置为当前节点；

    由于B的右孩子E不为空，根据操作1），输出E，并将其入栈，此时输出序列为：ABDE；

    由于E的左孩子为空，根据操作3），将栈顶节点E出栈，但不输出，并将其右孩子置为当前节点；

    由于E的右孩子为空，根据操作5），继续将栈顶节点A出栈，但不输出，并将其右孩子置为当前节点；

    由于A的右孩子C不为空，根据操作1），输出C，并将其入栈，此时输出序列为：ABDEC；

    由于A的左孩子F不为空，根据操作2），则将F置为当前节点，再根据操作1），输出F，并将其入栈，此时输出序列为：ABDECF；

    由于F的左孩子为空，根据操作3），将栈顶节点F出栈，但不输出，并将其右孩子置为当前节点；

    由于F的右孩子为空，根据操作5），继续将栈顶元素C出栈，但不输出，并将其右孩子置为当前节点；

    此时栈空，且C的右孩子为NULL，因此遍历结束。

    

二叉树的前序遍历非递归实现代码

    c/c++版

    /**
     * Definition for binary tree
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        vector preorderTraversal(TreeNode *root) {
           vector<int> preorder_vec;
           TreeNode *p=root;//定义用来指向当前访问的节点的指针  
           if(p==NULL) return preorder_vec;//若为空树，则返回空vector
           stack<TreeNode *> treenode_stack;//创建一个空栈
           //直到当前节点p为NULL且栈空时，循环结束 
           while(p||!treenode_stack.empty())
           {
              //从根节点开始，输出当前节点，并将其入栈，  
              //同时置其左孩子为当前节点，直至其没有左孩子，及当前节点为NULL  
               preorder_vec.push_back(p->val);
               treenode_stack.push(p);
               p=p->left;
               //如果当前节点p为NULL且栈不空，则将栈顶节点出栈，  
              //同时置其右孩子为当前节点,循环判断，直至p不为空 
               while(!p&&!treenode_stack.empty())
               {
                   p=treenode_stack.top();
                   treenode_stack.pop();
                   p=p->right;
               }
           }
        }
    };

    

    java版

    import java.util.ArrayList;
    import java.util.List;
    import java.util.Stack;

    /**
     * @ClassName: Main
     * @Description: 
     * @author Chengxi
     * @Date: 2017-10-6下午3:24:45
     */

    class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;
        public TreeNode(int val){
            this.val = val;
        }
    }
    public class Main {

        //二叉树的前根序非递归遍历的实现
        public static List treeQ(TreeNode root){

            List<Integer> list = new ArrayList<Integer>();

            //如果二叉树为空，直接返回空的list
            if(root == null)
                return list;
            Stack<TreeNode> stack = new Stack<TreeNode>();
            //当前结点的值为空并且栈也为空时循环结束
            while(root != null || !stack.empty()){
                list.add(root.val);
                stack.push(root);
                root = root.left;

                //当前节点为空并且stack不为空的情况下进行循环
                while(root == null && !stack.empty()){
                    //当root为空时，开始获取stack.pop元素的right直到对应root不为空
                    root = stack.pop().right;
                }
            }
            return list;
        }

        public static void main(String[] args){
        }
    }

    

二叉树的前序遍历的递归实现代码

    import java.util.ArrayList;
    import java.util.List;
    import java.util.Stack;

    /**
     * @ClassName: Main
     * @Description:
     * @author Chengxi
     * @Date: 2017-10-6下午3:24:45
     */

    class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }

    public class Main {

        public static List<Integer> list2 = new ArrayList<Integer>();
        public static void treeQ2(TreeNode root) {

            // 如果二叉树为空，直接返回空的list
            if(root == null)
                return ;
            list2.add(root.val);
            treeQ2(root.left);
            treeQ2(root.right);
        }

        public static void main(String[] args) {
        }
    }

    

参考

二叉树的遍历–平凡
二叉树的遍历