二叉树遍历一揽子——迭代方法非递归

二叉树遍历一揽子—迭代方法

二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的前序遍历。

代码

class Solution
{
public:
    vector<int> preorderTraversal(TreeNode *root)
    {
        vector<int> result;
        if (root == nullptr)
            return result;

        stack<TreeNode *> Stack;
        TreeNode *tmp = root;

        while (!Stack.empty() || tmp)
        {
            while (tmp)
            {
                result.push_back(tmp->val);
                Stack.push(tmp->right);
                tmp = tmp->left;
            }
            tmp = Stack.top();
            Stack.pop();
        }
        return result;
    }
};

模板

栈S;
p= root;
while(p || S不空){
    while(p){
        访问p节点；
        p的右子树入S;
        p = p的左子树;
    }
    p = S栈顶弹出;
}

二叉树的中序遍历

代码

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

模板

栈S;
p= root;
while(p || S不空){
    while(p){
        p入S;
        p = p的左子树;
    }
    p = S.top 出栈;
    访问p;
    p = p的右子树;
}

二叉树的后序遍历

代码

class Solution
{
public:
    vector<int> postorderTraversal(TreeNode *root)
    {
        vector<int> result;
        if (root == nullptr)
            return result;
        stack<TreeNode *> S;
        TreeNode *tmp = root;
        while (tmp || !S.empty())
        {
            while (tmp)
            {
                result.push_back(tmp->val);
                S.push(tmp->left);
                tmp = tmp->right;
            }
            tmp = S.top();
            S.pop();
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

模板

后序：LRD  ===>  其实是DRL的逆序，因此遍历时可以通过前序RLD然后逆序输出

    
栈S;
p= root;
while(p || S不空){
    while(p){
        访问p节点；
        p的左子树入S;
        p = p的右子树;
    }
    p = S栈顶弹出;
}

倒置数组

二叉树的层序遍历

代码

class Solution
{
public:
    vector<vector<int>> levelOrder(TreeNode *root)
    {
        vector<vector<int>> result;
        if (root == nullptr)
            return result;
        queue<TreeNode *> Q;
        Q.push(root);
        while (!Q.empty())
        {
            vector<int> res;
            int size = Q.size();
            for (int i = 0; i < size; i++)
            {
                TreeNode *tmp = Q.front();
                Q.pop();
                res.push_back(tmp->val);
                if (tmp->left)
                    Q.push(tmp->left);
                if (tmp->right)
                    Q.push(tmp->right);
            }
            result.push_back(res);
        }
        return result;
    }
};

模板

/**
 * 队列Q;
 * 二维数组result
 * root入队列Q
 * while(！Q.empty){
 *      一维数组res存储当前层元素
 *      size=当前队列的长度
 *      for循环size次，将当前层节点存入一维数组
 *      临时变量 tmp=队首弹出元素
 *      temp的值入一位数组res
 *      tmp的左子树不空的话，将tmp的左子树压入队列
 *      tmp的右子树不空的话，将tmp的右子树压入队列
 *      将res存入result，记录当前层节点
 * }
*/

从上到下打印二叉树

代码

class Solution
{
public:
    vector<int> levelOrder(TreeNode *root)
    {
        vector<int> result;
        if (root == nullptr)
            return result;
        queue<TreeNode *> Q;
        Q.push(root);
        while (Q.size())
        {

            int size = Q.size();
            for (int i = 0; i < size; i++)
            {
                TreeNode *tmp = Q.front();
                Q.pop();
                result.push_back(tmp->val);
                if (tmp->left)
                    Q.push(tmp->left);
                if (tmp->right)
                    Q.push(tmp->right);
            }
        }
        return result;
    }
};

模板

/**
 * 队列Q
 * 结果数组result
 * root入Q
 * while(Q不为空){
 *      size = Q的大小
 *      for循环size次{
 *          tmp= Q的队首
 *          队首弹出
 *          result放入Q的值
 *          tmp的左子树不为空：tmp的左子树入队列Q
 *          tmp的右子树不为空：tmp的右子树入队列Q
 *          }
 * }
 * 返回result
*/