二叉树的遍历（递归，非递归）实现

二叉树的遍历分为前序遍历，中序遍历，后序遍历，层次遍历，zigzag遍历（一层一层走S型），本文不讨论以上算法的递归实现，都是借助栈或者队列来实现。

前序遍历(Preorder)

vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        if(root==NULL)
            return result;
        stack<TreeNode*> helper;
        helper.push(root);
        while(!helper.empty()){

            TreeNode* node = helper.top();
            helper.pop();
            result.push_back(node->val);
            if(node->right)
                helper.push(node->right);
            if(node->left)
                helper.push(node->left);
        }
        return result;
    }

解释：从根节点开始遍历，首先访问根节点，然后分别将左子树遍历，再右子树，所以上面代码中会看到，先将右孩子压栈，再左孩子。进而实现前序遍历。

中序遍历(Inorder)

vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        if(root==NULL)
            return result;
        stack<TreeNode*> helper;
        TreeNode* current=root;
        while(!helper.empty()||current){
              if(current){
                    helper.push(current);
                    current = current->left;
              }else{
                    TreeNode* node = helper.top();
                    result.push_back(node);
                    helper.pop();
                    current = node->right;
              }
        }
        return result;
    }

解释：中序遍历其实和前序遍历非常的像，只不过这回，需要访问左边节点之后才能访问根节点。使用current表示当前访问的节点，只有当左节点被访问过或者左节点为空，才能被访问。所以每次如果左边节点不为空，那么需要从最左边开始。当current为NULL时，说明当前栈顶的节点左边为NULL或者已经被访问过，所以就访问当前栈顶，同时访问右子树。

后序遍历(PostOrder)

vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        if(root==NULL)
            return result;
        stack<TreeNode*> helper;
         TreeNode* pCur=root;
        TreeNode* last=NULL;
        while(pCur!=NULL){
            helper.push(pCur);
            pCur = pCur->left;
        }
        while(!helper.empty()){
            pCur = helper.top();
            helper.pop();
            if(pCur->right==NULL||pCur->right==last)
            {
                //无右节点或者右节点已经被访问过
                result.push_back(pCur->val);
                last=pCur;
            }else if(pCur->right!=last){
                helper.push(pCur);
                pCur = pCur->right;
                while(pCur!=NULL){
                    helper.push(pCur);
                    pCur = pCur->left;
                }
            }
        }
        return result;
    }
  //下面这样实现也是可以的
  vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
         if(root==NULL)
            return result;
        stack<TreeNode*> helper;
         TreeNode* cur=root,*last;
         while(!helper.empty()||cur!=NULL){
             if(cur){
                 helper.push(cur);
                 cur=cur->left;
             }else{
                 //没有右孩子或者右孩子已经被访问过了
                 TreeNode* node = helper.top();
                 helper.pop();
                 if(node->right==NULL||node->right==last){
                     result.push_back(node->val);
                     last = node;
                 }else{
                     cur = node->right;
                     helper.push(node);
                 }
             }
         }
         return result;
    }

解释：后序遍历会比较麻烦，因为每次都需要判断当前节点是否被访问过，所以需要记住前一个被访问的节点，也就是last.只有当前节点的右节点被访问过了，或者为空，这时候才可以访问当前的节点。否则，需要遍历右子树。

层次遍历后续补上。。。。