二叉树的前序、中序、后序遍历

二叉树通用的遍历树的策略有深度优先搜索（DFS），宽度优先搜索（BFS）或者叫广度优先搜索。

遍历方式有：前序遍历，中序遍历，后序遍历。

前序遍历：根节点→左子树→右子树。

中序遍历：左子树→根节点→右子树。

后序遍历：左子树→右子树→根节点。

二叉树的定义：

Struct TreeNode {
    int val;           //数据域
    TreeNode * left;   //指针域
    TreeNode * right;  //指针域
    TreeNode(int v) : val(v), left(NULL), right(NULL) { }
}

二叉树的遍历递归实现：

二叉树的前序遍历：

//二叉树前序遍历，递归实现
vector<int> ret;     //用来保存二叉树前序遍历的结果
void preoeder_Traversal(TreeNode * root) {
    pre_Traverse(root);
    return ret;
}
//前序遍历递归函数
void pre_Traverse(TreeNode * root) {
    if (root) {
        ret.push_back(root->val);    //将根节点的数据放入ret中
        pre_Traverse(root->left);    //左子节点
        pre_Travesre(root->right);    //右子节点
    }
}

二叉树的中序遍历：

//二叉树中序遍历，递归实现
vector<int> ret;     //用来保存二叉树中序遍历的结果
void inoeder_Traversal(TreeNode * root) {
    in_Traverse(root);
    return ret;
}
//中序遍历递归函数
void in_Traverse(TreeNode * root) {
    if (root) {
        in_Traverse(root->left);     //左子节点
        ret.push_back(root->val);    //将根节点的数据放入ret中
        in_Traverse(root->right);     //右子节点
    }
}

二叉树的后序遍历：

//二叉树后序遍历，递归实现
vector<int> ret;     //用来保存二叉树后序遍历的结果
void postorder_Traversal(TreeNode * root) {
    post_Traverse(root);
    return ret;
}
//后序遍历递归函数
void post_Traverse(TreeNode * root) {
    if (root) {
        post_Traverse(root->left);     //左子节点
        post_Traverse(root->right);     //右子节点
        ret.push_back(root->val);      //将根节点的数据放入ret中
    }
}

二叉树的遍历迭代实现：

二叉树的前序遍历：

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

二叉树的中序遍历：

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

二叉树的后序遍历：

vector<int> postorderTraversal(TreeNode* root) {
    vector<int> ret;
    stack<TreeNode *> stTreeNode;
    if (root != nullptr) stTreeNode.push(root);
    while (!stTreeNode.empty()) {
        TreeNode * temp = stTreeNode.top();
        stTreeNode.pop();
        if (temp != nullptr) {
            stTreeNode.push(temp);
            stTreeNode.push(nullptr);
            if (temp->right) stTreeNode.push(temp->right);
            if (temp->left) stTreeNode.push(temp->left);
        }
        else {
            ret.push_back(stTreeNode.top()->val);
            stTreeNode.pop();
        }
    }
    return ret;
}