代码随想录之二叉树的遍历

本内容来自代码随想录
二叉树的遍历需要一个遍历函数
前序：中左右
中序：左中右
后序：左右中

1.递归法

前序：

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

中序

class Solution {
public:
    vector<int> res;
    void traversal(TreeNode* cur){
        if(cur == nullptr) return ;
        traversal(cur->left);
        res.push_back(cur->val);
        traversal(cur->right);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        traversal(root);
        return res;
    }
};

后序

class Solution {
public:
    vector<int> res;
    void traversal(TreeNode* cur){
        if(cur==nullptr) return;
        traversal(cur->left);
        traversal(cur->right);
        res.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        traversal(root);
        return res;
    }
};

层序

class Solution {
public:
    vector<vector<int>> res;
    
    void traversal(TreeNode* cur,int dept){
        if(cur == nullptr) return; //叶子节点的子空节点返回
        if(res.size() == dept){ //先push_back一个空数组[]
            res.push_back(vector<int>());
        }
        res[dept].push_back(cur->val);//往空数组里放元素
        traversal(cur->left,dept+1);
        traversal(cur->right,dept+1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        int dept = 0;
        traversal(root,dept);
        return res;
    }
};

迭代法

迭代法是使用一个栈，然后根据对应的顺序(例如：中左右等)进行放入元素。

前序：

由于栈先进后出的性质，需要以中右左进行排左和右。

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if(root == nullptr) return res;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top(); //中
            st.pop();
            res.push_back(node->val);
            if(node->right) st.push(node->right); //右
            if(node->left) st.push(node->left);  // 左
        }
        return res;
    }
};

中序：

中序遍历比较特殊，迭代法的思路如下：
首先中序遍历是左中右，意味着要先遍历到二叉树左臂最深的地方，因此这里需要特殊处理

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        //本节点不空，栈也不空则继续遍历
        while(cur != nullptr || !st.empty()){
        	//本节点不为空，就继续往左走直到空了再说
            if(cur!=nullptr){
                st.push(cur);
                cur = cur->left;
            }else{
            	//本节点空了取栈顶元素，再中，再右
                cur = st.top();
                st.pop();
                res.push_back(cur->val);
                cur = cur -> right;
            }
        } 
        return res;
    }
};

后序：

后序和前序正好相反，前序遍历是中左右，先调整为中右左，得到的结果res数组，反转整个数组就是左右中

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

层序

使用queue容器进行层序遍历，使用sz控制一层多少个元素

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