LeetCode题解二叉树（三）：二叉树前中后序遍历的统一写法；105 二叉树的层序遍历

63 阅读 0 评论 42 点赞

我是靠谱客的博主欣喜汉堡，最近开发中收集的这篇文章主要介绍LeetCode题解二叉树（三）：二叉树前中后序遍历的统一写法；105 二叉树的层序遍历，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

二叉树的统一迭代法

这个方法避免了记忆三种方法的复杂性，但是据我自己的感受，有时候解题，统一写法也不一定就好用，还是都记一记比较好。

该统一写法的思想叫做标记法：将访问的结点放入栈中，把要处理的节点也放入栈中，但是要做标记。在二叉树深度遍历的迭代法中，标记就是空指针。

每当要处理的结点（中间节点）放入栈之后，紧接着放入一个空指针作为标记。

接下来引用随想录中三种遍历顺序的代码：

中序遍历——

vector<int> inorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> st;
    if (root != NULL) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        if (node != NULL) {
            st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
            if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

            st.push(node);                          // 添加中节点
            st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

            if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
        } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
            st.pop();           // 将空节点弹出
            node = st.top();    // 重新取出栈中元素
            st.pop();
            result.push_back(node->val); // 加入到结果集
        }
    }
    return result;
}

前序遍历——

vector<int> preorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> st;
    if (root != NULL) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        if (node != NULL) {
            st.pop();
            if (node->right) st.push(node->right);  // 右
            if (node->left) st.push(node->left);    // 左
            st.push(node);                          // 中
            st.push(NULL);
        } else {
            st.pop();
            node = st.top();
            st.pop();
            result.push_back(node->val);
        }
    }
    return result;
}

后序遍历——

vector<int> postorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> st;
    if (root != NULL) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        if (node != NULL) {
            st.pop();
            st.push(node);                          // 中
            st.push(NULL);

            if (node->right) st.push(node->right);  // 右
            if (node->left) st.push(node->left);    // 左

        } else {
            st.pop();
            node = st.top();
            st.pop();
            result.push_back(node->val);
        }
    }
    return result;
}

注意，前序的后序遍历，相较于中序遍历，只改变了两行代码。

思想既然是标记法，标记既然是空指针，那么就要对栈顶的元素是否为空进行判断了。如果栈顶元素为空，就说明栈顶的，下一个元素为中间的结点，先弹出栈顶元素，再记录新的栈顶元素（中间节点），并做相应处理（二叉树的遍历中，处理操作即是加入数组）。

如果遇到的元素不是空，就说明非中间节点，有可能是左孩子或者右孩子，那么就按照前中后序的遍历顺序依次入栈就可以了。注意放入当前结点的时候，需要加入一个空结点作为标记。

如果对此过程依旧不清晰的读者，可以自己动手画一颗简单的二叉树，手动遍历一遍就好了。

102 二叉树的层序遍历 medium

最正统，原汁原味的一道二叉树层序遍历的题目。

要把每层遍历到的数，放入一个新的数组中，返回数组的集合。

层序遍历和深度遍历不同，要先扫描完一整层，才能进入下一层。这时候就不能使用栈这种数据结构了，因为一层一层的遍历意味着先放入容器的值要先处理，而栈则是先入栈的数后处理。所以此处要使用队列这种，先入先出的数据结构。

层序遍历，使用迭代会更顺手一些（就像深度遍历使用递归会更顺手），也可以用递归的写法。

迭代法——

vector<vector<int>> levelOrder(TreeNode* root) {
    queue<TreeNode*> que;
    if (root != NULL) que.push(root);
    vector<vector<int>> result;
    while (!que.empty()) {
        int size = que.size();
        vector<int> vec;
        // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
        for (int i = 0; i < size; i++) {
            TreeNode* node = que.front();
            que.pop();
            vec.push_back(node->val);
            if (node->left) que.push(node->left);
            if (node->right) que.push(node->right);
        }
        result.push_back(vec);
    }
    return result;
}

递归法——

void order(TreeNode* cur, vector<vector<int>>& result, int depth)
{
    if (cur == nullptr) return;
    if (result.size() == depth) result.push_back(vector<int>());
    result[depth].push_back(cur->val);
    order(cur->left, result, depth + 1);
    order(cur->right, result, depth + 1);
}
vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> result;
    int depth = 0;
    order(root, result, depth);
    return result;
}