代码随想录算法训练营第十三天 | 二叉树part1

1、二叉树的递归遍历

递归遍历相对容易，改换一下顺序就好了，重要的理解递归，递归简单说就是函数自己调用自己，层层嵌套，再层层解开，不要用脑子想这个过程，越想越乱，思考每一层的逻辑就好了，保证每一此调用函数能够衔接稍上。

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        vec.push_back(cur->val);    
        traversal(cur->left, vec);  
        traversal(cur->right, vec); 
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
}

 2、迭代遍历，这里需要着重注意，递归可以用栈代替完成，每次弹出父节点再压入子节点，前序和后续遍历基本一致，改换一下顺序即可，因为前序遍历是先找到父节点再找到子节点，和数的结构一致，所有遍历到父节点，存入值，再压入子节点，再存入值，先来看前后续遍历：

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

        stack<TreeNode*> st;
        st.push(root);

        while(!st.empty())
        {
            TreeNode* tmp = st.top();
            st.pop();
            result.push_back(tmp->val);
            if (tmp->right) st.push(tmp->right);//更换压栈顺序实现后续          
            if (tmp->left) st.push(tmp->left); 

        }
        return result;//翻转result实现后续

    }
};

中序遍历就有所不同了，因为需要先把左子节点存入，再存入父节点，而根据树的结构·，先找到的是父节点，我们先找到最下面的左子节点，并把遍历路径存了，当处理完最坐下的节点后，在弹出存的节点，再处理它的右子节点

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;

        if (root == nullptr)
            return result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != nullptr || !st.empty()) {
            if (cur) {
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                result.push_back(cur->val);
                cur = cur->right;
            }
        }
        return result;
    }
};

3、层序遍历

栈可以实现二叉树的深度优先遍历，队列实现二叉树的广度优先遍历，把每一层的节点送入队列，再遍历队列，存储元素的同时再压入下一层的节点：

class Solution {
public:
    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;
    }
};