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

 今天好多题，虽然挺简单，抵不住多啊，又写到12点了，歇了

144. 二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {

public:    
    void preTravel(TreeNode *cur,vector<int> &res)//注意取地址
    {
        if(cur == NULL) return;
        res.push_back(cur->val);
        preTravel(cur->left,res);
        preTravel(cur->right,res);
    }

    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        preTravel(root,result);
        return result;


    }
};

145. 二叉树的后序遍历

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

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        midorder(root,result);
        return result;

    }
};

94. 二叉树的中序遍历 

class Solution {
public:

    void inorder(TreeNode *cur,vector<int> &res)
    {
        if(cur == NULL) return;
        inorder(cur->left,res);
        res.push_back(cur->val);
        inorder(cur->right,res);
    }

    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        inorder(root,result);
        return result;
    }
};

 102. 二叉树的层序遍历

 

class Solution {
public:
    void order(TreeNode *cur,vector<vector<int>> &res,int depth)
    {
        if(cur == NULL) return;
        if(depth == res.size()) res.push_back(vector<int>());
        res[depth].push_back(cur->val);
        order(cur->left,res,depth+1);
        order(cur->right,res,depth+1);        

    }

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root,result,depth);
        return result;
    }
};

107. 二叉树的层序遍历 II

class Solution {
public:
    void order(TreeNode *cur,vector<vector<int>> &res,int depth)
    {
        if(cur == NULL) return;
        if(depth == res.size()) res.push_back(vector<int>());//vector<int>是用来初始化新的一行的
        res[depth].push_back(cur->val);
        order(cur->left,res,depth + 1);
        order(cur->right,res,depth + 1);        
    }

    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root,result,depth);
        reverse(result.begin(),result.end());
        return result;
    }
};

199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

解答错误

输入

root =

[1,2,3,4]

添加到测试用例

输出

[1,3]

预期结果

[1,3,4]

果然还是用层序遍历好一些，这种方法处理不了这种情况，并且递归法太低效了

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

    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        order(root,result);
        return result;
    }
};

正确答案：

 

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> res;
        if(root == NULL) return res;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            for(int i = 0; i < size; i++)
            {
                TreeNode * p = que.front();
                que.pop();
                if(i == (size-1))
                {
                    res.push_back(p->val);
                }
                if(p->left) 
                {
                    que.push(p->left);
                }
                if(p->right)
                {
                    que.push(p->right);
                }

            }
        }
        return res;
    }
};

637. 二叉树的层平均值 

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        vector<double> res;
        if(root == NULL) return res;
        que.push(root);
        while(!que.empty())
        {
            double size = que.size();
            double sum = 0;
            for(int i = 0; i < size; i++)
            {
                TreeNode *p = que.front();
                que.pop();
                sum += p->val;
                if(p->left)
                {
                    que.push(p->left);
                }
                if(p->right)
                {
                    que.push(p->right);
                }
            }
            res.push_back(sum/size);
        }
        return res;

    }
};

429. N 叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        queue<Node*> que;
        if(root == NULL) return res;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            for(int i = 0; i < size; i++)
            {
                Node* p = que.front();
                que.pop();         
                vec.push_back(p->val);
                for(int i = 0; i < p->children.size(); i++)
                {
                    if(p->children[i]) que.push(p->children[i]);
                }       
            }
            res.push_back(vec);
        }
        return res;
        
    }
};

515. 在每个树行中找最大值

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> que;
        if(root == NULL) return res;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            int max = INT_MIN;
            for(int i = 0; i < size; i++ )
            {
                TreeNode * p = que.front();
                que.pop();
                max = max > p->val ? max : p->val;
                if(p->left) que.push(p->left);
                if(p->right) que.push(p->right);
            }
            res.push_back(max);
        }
    return res;
    }
};

116. 填充每个节点的下一个右侧节点指针

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root == NULL) return root;
        que.push(root);

        while(!que.empty())
        {
            int size = que.size();
            Node * preq;
            Node * curq;
            for(int i = 0; i < size ; i++)
            {
                if( i == 0)
                {
                    preq = que.front();
                    que.pop();
                }
                else
                {
                    curq = que.front();
                    que.pop();
                    preq->next = curq;
                    preq = preq->next;
                }
                if(preq->left) que.push(preq->left);
                if(preq->right) que.push(preq->right);
            }
        }
        return root;
    }
};

117. 填充每个节点的下一个右侧节点指针 II

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root == NULL) return root;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            Node * preq;
            Node * curq;
            for(int i = 0 ; i < size ; i++)
            {
                if(i == 0)
                {
                    preq = que.front();
                    que.pop();
                    curq = preq;
                }
                else
                {
                    curq = que.front();
                    que.pop();
                    preq->next = curq;
                    preq = preq->next;
                }
                if(preq->left) que.push(preq->left);
                if(preq->right) que.push(preq->right);               
            }
        }
        return root;
        
    }
};

104. 二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == NULL) return 0;
        que.push(root);
        int depth = 0;
        while(!que.empty())
        {
            int size = que.size();
            depth++;
            for(int i = 0 ; i < size ; i++)
            {
                TreeNode * p =que.front();
                que.pop();
                if(p->left) que.push(p->left);
                if(p->right) que.push(p->right);
            }
        }
        return depth;
    }
};

111. 二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == NULL) return 0;
        que.push(root);
        int depth = 0;
        while(!que.empty())
        {
            int size = que.size();
            depth++;
            for(int i = 0 ; i < size ; i++)
            {
                TreeNode * p =que.front();
                que.pop();
                if(p->left) que.push(p->left);
                if(p->right) que.push(p->right);
                if(!p->left && !p->right) return depth;
            }
        }
        return depth;
    }
};