遍历二叉树的算法

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

void postOrder(TreeNode* root)
{
   if(root!=NULL)
   {
      postOrder(root->left);
      postOrder(root->right);
      vec.push_back(root->val);
   }    
}

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

vector<int> postorderTraversal(TreeNode *root)
{
    vector<int> vec;
    TreeNode* p=root;
    TreeNode* r=NULL;
    stack<TreeNode *> s;
    while(p||!s.empty())
    {
        if(p)
        {
            s.push(p);
            p=p->left;

        }else
        {
            p=s.top();

            if(p->right&&p->right!=r)
            {
                p=p->right;
                s.push(p);
                p=p->left;
            }else
            {
                r=s.top();
                vec.push_back(r->val);
                s.pop();
                p=NULL;

            }

        }
    }
    return vec;
}

递归实现先序遍历二叉树：

void preorder(TreeNode* root)
{
    if(root)
    {
        vec.push_back(root->val);
        preorder(root->left,vec);
        preorder(root->right,vec);
    }
 }

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

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

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

void Inorder(TreeNode* root)
{
    if(root)
    {
        InOrder(root->left);
        vec.push_back(root->val);
        InOrder(root->right);
    }
}

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

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