LeetCode 力扣 刷题记录 热题 HOT 100（101，102，104，105，114）题目+算法分析+Cpp解答

GitHub链接：https://github.com/WilliamWuLH/LeetCode

如果你觉得不错可以 ⭐Star 和 Fork ❤

101.Symmetric Tree

迭代法：

​ 大问题变成小问题，不断迭代到可以进行判断，再返回判断结果。

​ 判断两边：

• 首先判断两个根结点是否相同；

• 再判断左边根结点的左子树和右边根结点的右子树是否相同；

• 再判断左边根结点的右子树和右边根结点的左子树是否相同；

  ​ 在判断是否相同时：

• 两个根结点均为 null，返回 true；

• 两个根结点中有一个是 null，有一个不是，返回 false；

• 两个根结点均不为 null，判断两个根结点的 val 值是否相同，再判断它们的左右子树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)
            return true;
        return mirror(root->left, root->right);
    }
    bool mirror(TreeNode* node1, TreeNode* node2){
        if(node1 == NULL && node2 == NULL)
            return true;
        else if(node1 == NULL || node2 == NULL)
            return false;
        else
            return (node1->val == node2->val) 
                    && mirror(node1->left, node2->right)
                    && mirror(node1->right, node2->left);
    }
};

102.Binary Tree Level Order Traversal

二叉树的层次遍历：

​ 层次遍历需要记录遍历到哪一层。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        levelorder(0, root, ans);
        return ans;
    }
    void levelorder(int level, TreeNode* root, vector<vector<int>>& ans){
        if(root == NULL)
            return;
        if(level >= ans.size()){
            vector<int> temp;
            temp.push_back(root->val);
            ans.push_back(temp);
        }
        else
            ans[level].push_back(root->val);
        levelorder(level+1, root->left, ans);
        levelorder(level+1, root->right, ans);
    }
};

104.Maximum Depth of Binary Tree

深度优先搜索 DFS：递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int ans = 0;
    int maxDepth(TreeNode* root) {
        dfs(1, root);
        return ans;
    }
    void dfs(int depth, TreeNode* root){
        if(root == NULL)
            return;
        ans = max(ans, depth);
        dfs(depth+1, root->left);
        dfs(depth+1, root->right);
    }
};

深度优先搜索 DFS：栈 stack

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        typedef pair<TreeNode*, int> depth;
        int ans = 0;
        stack<depth> nodes;
        depth d(root, 1);
        nodes.push(d);
        while(!nodes.empty()){
            depth temp = nodes.top();
            nodes.pop();
            if(temp.first != NULL){
                ans = max(ans, temp.second);
                depth l(temp.first->left, temp.second+1);
                nodes.push(l);
                depth r(temp.first->right, temp.second+1);
                nodes.push(r);
            }
        }
        return ans;
    }
};

105.Construct Binary Tree from Preorder and Inorder Traversal

分治 + 递归：

​ 前序遍历的第一个值为该二叉树的根结点值。

​ 根据得到的根结点值，可以在中序遍历中找到该根结点值的位置，由于中序遍历是先左子树，再根结点，再右子树，所以在中序遍历中，根结点的位置划分出来的左边为左子树，右边为右子树。

​ 根据中序遍历中根结点的位置左边的元素个数，可以得到左子树的结点个数，根据左子树的结点个数可以在前序遍历中得到左子树的前序遍历和右子树的前序遍历。

​ 此时确定了根结点、左子树和右子树，把左子树和右子树当成是独立的一棵二叉树继续递归，并且返回子树的根结点，作为此时（大二叉树）根结点的左子结点和右子结点，由此构造出整棵二叉树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.empty())
            return 0;
        TreeNode* root = new TreeNode(preorder[0]);
        int count = 0;
        for(count = 0; count < inorder.size(); count++){
            if(inorder[count] == preorder[0])
                break;
        }
        vector<int> pre1(preorder.begin()+1, preorder.begin()+1+count);
        vector<int> ino1(inorder.begin(), inorder.begin()+count);
        vector<int> pre2(preorder.begin()+1+count, preorder.end());
        vector<int> ino2(inorder.begin()+1+count, inorder.end());
        root->left = buildTree(pre1, ino1);
        root->right = buildTree(pre2, ino2);
        return root;
    }
};

114.Flatten Binary Tree to Linked List

先序遍历 + 插入子树：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void flatten(TreeNode* root) {
        while(root != NULL){
            if(root->left == NULL)
                root = root->right;
            else{
                TreeNode* r = root->left;
                while(r->right != NULL)
                    r = r->right;
                r->right = root->right;
                root->right = root->left;
                root->left = NULL;
            }
        }
    }
};