刷题Day7

今天的题目和二叉树相关

1.二叉树的dfs（递归实现）

1.1前序遍历（中左右）

先把根节点压入数组，然后递归遍历左子树和右子树，最后把左右子树合并到result数组里面

vector<int> preorderTraversal(TreeNode* root) {
    vector<int>result;
    if(root==nullptr){
        return result;
    }
    result.push_back(root->val);
    vector<int>left=preorderTraversal(root->left);
    vector<int>right=preorderTraversal(root->right);
    result.insert(result.end(),left.begin(),left.end());
    result.insert(result.end(),right.begin(),right.end());
    return result;
}

1.2中序遍历（左中右）

就是换个顺序罢了

vector<int> inorderTraversal(TreeNode* root) {
       
        vector<int>result;
    if(root==nullptr){
        return result;
    }
    vector<int>left=inorderTraversal(root->left);
    vector<int>right=inorderTraversal(root->right);
    result.insert(result.end(),left.begin(),left.end()); 
    result.push_back(root->val);
    result.insert(result.end(),right.begin(),right.end());
   
    return result;
    }

1.3后序遍历（左右中）

换个顺序

vector<int> postorderTraversal(TreeNode* root) {
        vector<int>result;
    if(root==nullptr){
        return result;
    }
    vector<int>left=postorderTraversal(root->left);
    vector<int>right=postorderTraversal(root->right);
    result.insert(result.end(),left.begin(),left.end());
    result.insert(result.end(),right.begin(),right.end());
    result.push_back(root->val);
    return result;
    }

2.二叉树的dfs(非递归实现)

2.1前序

先处理中间节点,在处理左右子树

vector<int>preorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> stk;
    if(root==nullptr){
        return result;
    }
    stk.push(root);

    while(!stk.empty()){
        TreeNode*node=stk.top();
        stk.pop();
        result.push_back(node->val);
        if(node->right){
            stk.push(node->right);
        }
        if(node->left){
            stk.push(node->left);
        }
    }

    return result;
}

2.2中序

先把所有左子树都入栈,然后再去处理中间有右子树

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

2.3后序

使用数组来存储后序的好处就是,可以直接反转,前序和后序的顺序正好完全相反,所以改变一下压栈的时机就可以解决,最后只需要reverse一下就可以了

vector<int> postorderTraversal(TreeNode* root) {
         vector<int> result;
    stack<TreeNode*> stk;
    if(root==nullptr){
        return result;
    }
    stk.push(root);

    while(!stk.empty()){
        TreeNode*node=stk.top();
        stk.pop();
        result.push_back(node->val);
       
        if(node->left){
            stk.push(node->left);
        } 
        if(node->right){
            stk.push(node->right);
        }
    }
    reverse(result.begin(), result.end());
    return result;
    }

3.二叉树的bfs

我们通过队列来存储当前层的节点，从队列中取出节点时，表示当前层的节点已经被访问。然后将该节点的左右子节点加入队列，直到队列为空。每一层的节点数是 q.size()，我们通过循环遍历当前层所有的节点，并记录它们的值。每一层的节点值被存储在 levelValues 中，然后加入最终的 result 中。

   vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> result;
    if (root == nullptr) return result; 
    
    queue<TreeNode*> q;  
    q.push(root);
    
    while (!q.empty()) {
        int levelSize = q.size(); 
        vector<int> levelValues;   
        
 
        for (int i = 0; i < levelSize; ++i) {
            TreeNode* node = q.front();
            q.pop();
            levelValues.push_back(node->val);
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
        result.push_back(levelValues);
    }
    
    return result;
}

再加一点难度，如果想要倒着遍历该如何是好呢？

那其实就是每次在result里面添加的时候添加到顶部就可以了

 vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
    if (root == nullptr) return result; 
    
    queue<TreeNode*> q;  
    q.push(root);
    
    while (!q.empty()) {
        int levelSize = q.size(); 
        vector<int> levelValues;   
        
 
        for (int i = 0; i < levelSize; ++i) {
            TreeNode* node = q.front();
            q.pop();
            levelValues.push_back(node->val);
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
        result.insert(result.begin(),levelValues);
    }
    
    return result;

    }

4.二叉树的右视图  199. 二叉树的右视图 - 力扣（LeetCode）

想看到二叉树的右视图，其实就是把二叉树的每一行的最右边的元素放到数组里面

vector<int> rightSideView(TreeNode* root) {
         vector<int>ans;
         if(root==nullptr){
            return ans;
         }
         queue<TreeNode*>que;
         que.push(root);
         while(!que.empty()){
            int size=que.size();

            for(int i=0;i<size;i++){
                TreeNode*cur=que.front();
                que.pop();
                if (i == (size - 1)) ans.push_back(cur->val);
                if(cur->left){
                    que.push(cur->left);
                }
                if(cur->right){
                    que.push(cur->right);
                }
            }
         }
         return ans;
    }

5.二叉树的层平均值  637. 二叉树的层平均值 - 力扣（LeetCode）

二叉树的层平均值其实就是遍历每一层的时候记录一下，然后除以每一行的元素个数就可以了

vector<double> averageOfLevels(TreeNode* root) {
        vector<double>result;
        queue<TreeNode*>que;
        if(root==nullptr){
            return result;
        }
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            double ans=0;
            for(int i=0;i<size;i++){
                TreeNode*cur=que.front();
                que.pop();
                ans+=cur->val;
                if(cur->left){
                    que.push(cur->left);
                }
                if(cur->right){
                    que.push(cur->right);
                }

            }
            result.push_back(ans*1.0/size);
        }
        return result;
    }

6.N叉树的层序遍历  429. N 叉树的层序遍历 - 力扣（LeetCode）

其实就是在压入队列的时候不再是只判断两个孩子了,而是要判断n个,也就是children的大小个

 vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>>result;
        queue<Node*>que;
        if(root==nullptr){
            return result;
        }
        que.push(root);
        while(!que.empty()){
            vector<int>curans;
            int size=que.size();
            for(int i=0;i<size;i++){
                Node*cur=que.front();
                que.pop();
                curans.push_back(cur->val);
                int cursize=cur->children.size();
                for(int j=0;j<cursize;j++){
                    Node*curr=cur->children[j];
                    if(curr){
                        que.push(curr);
                    }
                }
            }
            result.push_back(curans);
        }
        return result;
    }

7.找到每一行的最大值  515. 在每个树行中找最大值 - 力扣（LeetCode）

其实很简单,遍历的时候存下来就可以了

vector<int> largestValues(TreeNode* root) {
        vector<int>maxresult;
        queue<TreeNode*>que;
        if(root==nullptr){
            return maxresult;
        }
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            int maxx=INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode*cur=que.front();
                que.pop();
                maxx=max(maxx,cur->val);
                if(cur->left){
                    que.push(cur->left);
                }
                if(cur->right){
                    que.push(cur->right);
                }
            }
            maxresult.push_back(maxx);
        }
        return maxresult;
    }