二叉树的先序，中序，后序，层序遍历的非递归实现

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

    vector<int> preorderTraversal(TreeNode* root) {
       vector<int> result;
        if(root==nullptr)
            return result;
        
        stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty())
        {
            TreeNode* p=stk.top();
            stk.pop();
            result.push_back(p->val);
            
            if(p->right!=nullptr) stk.push(p->right);
            if(p->left!=nullptr) stk.push(p->left);
        }
        
        return result;
        
    }

二叉树中序遍历非递归实现：

 

    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        if(root==nullptr)
            return result;
        
        stack<TreeNode*> stk;
        TreeNode*p=root;
        
        while(!stk.empty()||p!=nullptr)
        {
            if(p!=nullptr)
            {
                stk.push(p);
                p=p->left;
            }
            else
            {
                p=stk.top();
                stk.pop();
                result.push_back(p->val);
                p=p->right;
            }
        }
        return result;
    }

二叉树的后序遍历非递归实现：

vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        if(root==nullptr)
            return result;
        
        stack<TreeNode*> stk;
        //p正在访问的节点，q刚刚访问过的节点
        TreeNode* p=root;
        TreeNode* q=nullptr;
        
        do{
            //往左下走
            while(p!=nullptr)
            {
                stk.push(p);
                p=p->left;
            }
            q=nullptr;
            
            while(!stk.empty())
            {
                p=stk.top();
                stk.pop();
                //右节点不存在或已经访问过，访问该节点
                if(p->right==q)
                {
                    result.push_back(p->val);
                    q=p;//保存刚刚访问过的节点
                }
                else
                {
                    stk.push(p);
                    //先处理右子树
                    p=p->right;
                    break;
                }
            }   
        }while(!stk.empty());
        return result;
    }
};

二叉树层序遍历实现：

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int> > result;
        if(root==nullptr)
            return result;
        
        queue<TreeNode*> curq,nextq;
        curq.push(root);
        while(!curq.empty())
        {
            //定义一个在该层上的容器
            vector<int> level;
            while(!curq.empty())
            {
                TreeNode*p=curq.front();
                curq.pop();
                level.push_back(p->val);
                if(p->left!=nullptr)
                    nextq.push(p->left);
                if(p->right!=nullptr)
                    nextq.push(p->right);
            }
            result.push_back(level);
            swap(curq,nextq);
        }
        return result;
    }