二叉树的常用遍历

树是一种经常用到的数据结构，用来模拟具有树状结构性质的数据集合。

树里的每一个节点有一个值和一个包含所有子节点的列表。从图的观点来看，树也可视为一个拥有N 个节点和N-1 条边的一个有向无环图。

二叉树是一种更为典型的树状结构。如它名字所描述的那样，二叉树是每个节点最多有两个子树的树结构，通常子树被称作“左子树”和“右子树”。

定义树的节点结构如下：

 struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode() : val(0), left(nullptr), right(nullptr) {}
     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 };

1. 二叉树的前序遍历(非递归)

前序遍历首先访问根节点，然后遍历左子树，最后遍历右子树。

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

2. 二叉树的中序遍历(非递归)

中序遍历是先遍历左子树，然后访问根节点，然后遍历右子树。

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

3. 二叉树的后序遍历(非递归)

后序遍历是先遍历左子树，然后遍历右子树，最后访问树的根节点。

前序：根-左-右

后序：左-右-根

后序相当于 [根-右-左] 的逆序。

对于迭代求前序遍历可以根节点先入栈，然后右子树进栈，最后左子树进栈；

此时便可以根节点先入栈，然后左子树进栈，最后右子树进栈，最后将列表逆序即为所求。

vector<int> postorderTraversal(TreeNode* root) {
    vector<int> res;
    if(root == nullptr)
        return res;
    stack<TreeNode*> stk;
    stk.push(root);
    while(!stk.empty()){
        TreeNode *p = stk.top();
        stk.pop();
        res.push_back(p->val);
        if(p->left)
            stk.push(p->left);
        if(p->right)
            stk.push(p->right);
    }
    reverse(res.begin(), res.end());
    return res;
}

4. 层次遍历

层序遍历就是逐层遍历树结构。

广度优先搜索是一种广泛运用在树或图这类数据结构中，遍历或搜索的算法。 该算法从一个根节点开始，首先访问节点本身。 然后遍历它的相邻节点，其次遍历它的二级邻节点、三级邻节点，以此类推。

• 如果不需要确定当前遍历到了哪一层，模板如下：

vector<int> levelOrder(TreeNode* root) {
    vector<int> res;
    if(root == nullptr)
        return res;
    queue<TreeNode*> que;
    que.push(root);
    while(!que.empty()){
        TreeNode *p = que.front();
        res.push_back(p->val);
        que.pop();
        if(p->left)
            que.push(p->left);
        if(p->right)
            que.push(p->right);
    }
    return res;
}

• 如果需要确定遍历到哪一层(按层打印)，模板如下；

vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> res;
    if(root == nullptr)
        return res;
    queue<TreeNode*> que;
    que.push(root);
    while(!que.empty()){
        vector<int> temp;
        int n = que.size();
        for(int i = 0; i < n; i++){
            TreeNode *p = que.front();
            temp.push_back(p->val);
            que.pop();
            if(p->left)
                que.push(p->left);
            if(p->right)
                que.push(p->right);
        }
        res.push_back(temp);
    }
    return res;
}

学习来源：leetcode二叉树
链接：https://leetcode-cn.com/leetbook/read/data-structure-binary-tree/x63shc/