代码随想录算法训练营day13

二叉树的遍历

1.递归遍历 递归的设计三要素： 1.确定返回值和传入参数 2.设置最底层递归的终止条件 3.设计单层递归的逻辑结构和算法 先序

private: //确定存贮结点的数据结构
        vector<int> result;
public:
    vector<int> preorderTraversal(TreeNode* root) {
        
        TreeNode* curr=root;
        //确定底层递归返回的条件
        if(curr==nullptr) return result;
        result.push_back(root->val);  
        preorderTraversal(curr->left);
        preorderTraversal(curr->right);
        return result;
     
    }
};

中序

private: //确定存贮结点的数据结构
        vector<int> result;
public:
    vector<int> preorderTraversal(TreeNode* root) {
        
        TreeNode* curr=root;
        //确定底层递归返回的条件
        if(curr==nullptr) return result;
         
        preorderTraversal(curr->left);
        result.push_back(root->val); 
        preorderTraversal(curr->right);
        return result;
     
    }
};

后序

class Solution {
private: //确定存贮结点的数据结构
        vector<int> result;
public:
    vector<int> preorderTraversal(TreeNode* root) {
        
        TreeNode* curr=root;
        //确定底层递归返回的条件
        if(curr==nullptr) return result;
         
        preorderTraversal(curr->left)；   
        preorderTraversal(curr->right);
        result.push_back(root->val);
        return result;
     
    }
};

普通迭代版 先序遍历，注意，采用栈结构就可以完成，具体后序遍历的迭代思路也是相同的

class Solution {
private: //确定存贮结点的数据结构
        vector<int> result;
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (root == nullptr) return result;

        TreeNode* curr=root;
        stack<TreeNode *> st;
       //迭代算法进行遍历
       st.push(curr);
       while(!st.empty()){
        //访问栈顶结点并存储在结果中
        curr=st.top();
       if(curr!=nullptr) result.push_back(curr->val);

        //弹出并按照先序遍历设计将左右节点压入栈
        st.pop();
        if(curr!=nullptr){
             if(curr->right!=nullptr) st.push(curr->right);
             if(curr->left!=nullptr)  st.push(curr->left);
        }
       

       }
       return result;
     
    }
};

后序遍历

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur=root;
        if(root==nullptr) return result;
        st.push(cur);
         while (!st.empty()) {
            TreeNode* cur = st.top();
            st.pop();
            
            // 1. 先访问根节点（对应前序的「根」）
            result.push_back(cur->val);
            
            // 2. 先压左子节点，后压右子节点（栈后进先出，保证先访问右子节点）
            // 最终遍历顺序：根 → 右 → 左
            if (cur->left != nullptr) {
                st.push(cur->left);
            }
            if (cur->right != nullptr) {
                st.push(cur->right);
            }
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

中序遍历

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