wy的leetcode刷题记录_Day30_二叉树起点！

wy的leetcode刷题记录_Day30_二叉树起点！

时间：2022-11-1

1662. 检查两个字符串数组是否相等

今天的每日一题是：1662. 检查两个字符串数组是否相等

题目介绍

给你两个字符串数组 word1 和 word2 。如果两个数组表示的字符串相同，返回 true ；否则，返回 false 。

数组表示的字符串 是由数组中的所有元素 按顺序 连接形成的字符串。

示例 1：
输入：word1 = [“ab”, “c”], word2 = [“a”, “bc”]
输出：true
解释： word1表示的字符串为 “ab” + “c” -> “abc” word2 表示的字符串为 “a” + “bc” -> "abc"两个字符串相同，返回 true

示例 2：
输入：word1 = [“a”, “cb”], word2 = [“ab”, “c”]
输出：false

思路

方法一：阅读题目后，发现题目要求的就是将比较这俩个vector中的子string合并后的string是否相等。于是我们按照题意把俩个vector中的子string合并后比较其是否相等就ok了。
方法二：双指针（不止两个）+贪心：更进一步的解法，解法一中我们另外声明了俩个string的变量，而在此解法中我们将直接在word1和word2上进行求解。首先我们使用两个指针p1和p2来表示指向word中第几个子string，再用i和j表示指向子string中的第几个字符，于是我们只需要比较word1[p1][i] 和word2[p2][j]。如果不相等的话直接返回false，否则i++和j++子字符串向后遍历，直到i或者j到了该子字符串的最大长度，此时p1或者p2指针后移就可以了最终两个数组相等条件即为 p1=word1.size()并且 p2=word2.size()。

代码

class Solution {
public:
    bool arrayStringsAreEqual(vector<string>& word1, vector<string>& word2) {
        string s1;
        string s2;
        for(string s:word1)
        {
            s1+=s;
            // s1.append(s);
        }
        for(auto s:word2)
        {
            s2+=s;
            // s2.append(s);

        }
        return s1==s2;
    }
};

收获

简单的模拟题，能想到的优化也就是空间了，时间已经无法优化了…

二叉树的起点！

2022-11-1，今天是十一月的第一天，也是我重新开始学习二叉树、开始刷二叉树的题的第一天，今天复习了理论，和最基础的二叉树的遍历方式，下面就是二叉树的三种最基础的遍历方式：
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:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        preVal(root,ans);
        return ans;
    }
    void preVal(TreeNode* node,vector<int> &ans)
    {
        if(node==nullptr)
            return ;
        ans.push_back(node->val);
        preVal(node->left,ans);
        preVal(node->right,ans);
    }
};

前序遍历非递归

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if (root == nullptr) {
            return res;
        }

        stack<TreeNode*> stk;
        TreeNode* node = root;
        while (!stk.empty() || node != nullptr) {
            while (node != nullptr) {
                res.emplace_back(node->val);
                stk.emplace(node);
                node = node->left;
            }
            node = stk.top();
            stk.pop();
            node = node->right;
        }
        return res;
    }
};

中序遍历 递归

/**
 * 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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        inVal(root,ans);
        return ans;
    }
    void inVal(TreeNode* node,vector<int> &ans)
    {
        if(node==nullptr)
            return ;
        inVal(node->left,ans);
        ans.push_back(node->val);
        inVal(node->right,ans);
    }
};

中序遍历 非递归

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

后序遍历 非递归

/**
 * 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:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        postVal(root,ans);
        return ans;
    }
        void postVal(TreeNode* node,vector<int> &ans)
    {
        if(node==nullptr)
            return ;
        postVal(node->left,ans);
        postVal(node->right,ans);
        ans.push_back(node->val);
    }
};

后序遍历 非递归

class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> res;
        if (root == nullptr) {
            return res;
        }

        stack<TreeNode *> stk;
        TreeNode *prev = nullptr;
        while (root != nullptr || !stk.empty()) {
            while (root != nullptr) {
                stk.emplace(root);
                root = root->left;
            }
            root = stk.top();
            stk.pop();
            if (root->right == nullptr || root->right == prev) {
                res.emplace_back(root->val);
                prev = root;
                root = nullptr;
            } else {
                stk.emplace(root);
                root = root->right;
            }
        }
        return res;
    }
};

收获

复习了之前数据结构中二叉树的结构，和一些特殊二叉树的定义，以及最基本的二叉树的三种遍历方式(递归+非递归)