牛客刷题日记【比较版本号|二叉树的三序遍历|二叉树的最大深度】

BM22 比较版本号

牛客项目发布项目版本时会有版本号，比如1.02.11，2.14.4等等

现在给你2个版本号version1和version2，请你比较他们的大小

版本号是由修订号组成，修订号与修订号之间由一个"."连接。1个修订号可能有多位数字组成，修订号可能包含前导0，且是合法的。例如，1.02.11，0.1，0.2都是合法的版本号

每个版本号至少包含1个修订号。

修订号从左到右编号，下标从0开始，最左边的修订号下标为0，下一个修订号下标为1，以此类推。

比较规则：

一. 比较版本号时，请按从左到右的顺序依次比较它们的修订号。比较修订号时，只需比较忽略任何前导零后的整数值。比如"0.1"和"0.01"的版本号是相等的

二. 如果版本号没有指定某个下标处的修订号，则该修订号视为0。例如，“1.1"的版本号小于"1.1.1”。因为"1.1"的版本号相当于"1.1.0"，第3位修订号的下标为0，小于1

三. version1 > version2 返回1，如果 version1 < version2 返回-1，不然返回0.

数据范围：

1<=version1.length,version2.length<=10001<=version1.lengt**h,version2.lengt**h<=1000

version1 和 version2 的修订号不会超过int的表达范围，即不超过 32 位整数 的范围

进阶： 空间复杂度 O(1)O(1) ， 时间复杂度 O(n)O(n)

思考：

把版本号转成数组，然后对数组进行比较；如果前半部分的数组等长，对后面部分进行逐个判断即可

代码：

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 比较版本号
     * @param version1 string字符串 
     * @param version2 string字符串 
     * @return int整型
     */
    
    vector<int> getNum(string version) {
        int num = 0;
        vector<int> nums;

        for (int i = 0;i < version.size();i++)  {
            if (version[i] == '.') {
            // if (version[i] == '.') {
                nums.push_back(num);
                num = 0;
                continue;
            }
            num *= 10;
            num += version[i] - '0';
        }

        return nums;
    }

    int compare(string version1, string version2) {
        // write code here

        vector<int> nums1;
        vector<int> nums2;

        nums1 = getNum(version1+".");
        nums2 = getNum(version2+".");

        // for (int i = 0;i < nums1.size();i++) std::cout << nums1[i] << " ";
        // std::cout << std::endl;
        // for (int i = 0;i < nums2.size();i++) std::cout << nums2[i] << " ";
        // std::cout << std::endl;


        for (int i = 0; i < min(nums1.size() , nums2.size());i++) {
            if (nums1[i] > nums2[i]) return 1;
            if (nums1[i] < nums2[i]) return -1;
        }

        if (nums1.size() > nums2.size()) {
            for (int i = nums2.size();i < nums1.size();i++) if (nums1[i]) return 1;
            return 0;
        }
        if (nums1.size() < nums2.size()) {
            for (int i = nums1.size();i < nums2.size();i++) if (nums2[i]) return -1;
            return 0;
        }

        return 0;
    }
};

BM23-25 二叉树的三序遍历

用递归的方式实现遍历，分别以：

1. 先序：根左右
2. 中序：左根右
3. 后序：左右根

先序：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
#include <vector>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    
    void pre(TreeNode* root, vector<int>& nums) {
        if (root) {
            nums.push_back(root->val);
            pre(root->left,nums);
            pre(root->right,nums);
        }
        return;
    }

    vector<int> preorderTraversal(TreeNode* root) {
        // write code here

        vector<int> res;
        pre(root, res);

        return res;
    }
};

中序：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    
    void in(TreeNode* root, vector<int>& nums) {
        if (root) {
            in(root->left,nums);
            nums.push_back(root->val);
            in(root->right,nums);
        }
        return;
    }

    vector<int> inorderTraversal(TreeNode* root) {
        // write code here
        vector<int> res;
        in(root, res);

        return res;
    }
};

后序：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */

    void post(TreeNode* root, vector<int>& nums) {
        if (root) {
            post(root->left,nums);
            post(root->right,nums);
            nums.push_back(root->val);
        }
        return;
    }    


    vector<int> postorderTraversal(TreeNode* root) {
        // write code here
        vector<int> res;
        post(root, res);

        return res;
    }
};

BM28 二叉树的最大深度

求给定二叉树的最大深度，

深度是指树的根节点到任一叶子节点路径上节点的数量。

最大深度是所有叶子节点的深度的最大值。

（注：叶子节点是指没有子节点的节点。）

数据范围：0≤n≤1000000≤n≤100000，树上每个节点的val满足 ∣val∣≤100∣val∣≤100
要求： 空间复杂度 O(1)O(1),时间复杂度 O(n)O(n)

思考：

对二叉树递归遍历寻找叶子节点，并明确每个叶子节点的高度，如果高度高于当前最高高度则更新

代码：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    
    int maxdepth = 0;

    void maxDepthIs(TreeNode* root, int depth) {
        if (!root) {
            if (maxdepth < depth) maxdepth = depth;
            return ;
        }
        maxDepthIs(root->left, depth+1);
        maxDepthIs(root->right, depth+1);
    }

    int maxDepth(TreeNode* root) {
        // write code here

        maxDepthIs(root, 0);

        return maxdepth;
    }
};