2022-03-07Leetcode训练营

本文链接：https://blog.csdn.net/lucifer80861/article/details/123340855

这篇博客介绍了两种解决算法问题的方法：一是使用哈希表来寻找数组中的多数元素，时间复杂度为O(N)，另一种是通过摩尔投票算法实现相同目标；二是利用递归从先序和中序遍历序列构造二叉树，同时也给出了迭代解法。博客强调了在学习过程中理解并选择合适算法的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

LC169多数元素

哈希，实间O(N),空间O(N)

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        unordered_map<int, int> s;
        int f=0;//最多的出现次数
        int ans;
        for(auto num:nums){
            s[num]++;
            if(s[num] > f){
                ans=num;
                f=s[num];
            }
        }
        return ans;
    }
};

摩尔投票算法
题解链接

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int freq=0;//频数
        int ans=nums[0];
        for (auto num:nums){
            if(num != ans){
                freq--;
                if(freq==0){
                    ans=num;
                    freq++;
                }
            }
            else{
                freq++;
            }
        }
        return ans;
    }
};

LC105从前序与中序遍历序列构造二叉树

题解链接
递归

class Solution {
public:
    unordered_map<int, int> index;

    TreeNode* myBuildTree(vector<int>& preorder, vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right){
        if(preorder_left > preorder_right) return nullptr;
        int preorder_root = preorder_left;//root在preorder里面的序号
        int inorder_root = index[preorder[preorder_root]];//root在inorder里面的序号
        TreeNode* root = new TreeNode(inorder[inorder_root]);
        int size_left_tree=inorder_root-inorder_left;
        root->left=myBuildTree(preorder, inorder, preorder_left+1, preorder_left+size_left_tree, inorder_left, inorder_root-1);
        root->right=myBuildTree(preorder, inorder, preorder_left+size_left_tree+1, preorder_right, inorder_root+1, inorder_right);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        //哈希是为了定位root在中序序列里面的位置，能一步到位找到root，从而知道左子和右子的序列长度
        int n = preorder.size();
        for(int i=0; i<n; ++i){
            index[inorder[i]]=i;
        }
        return myBuildTree(preorder, inorder, 0, n-1, 0, n-1);
    }
};

迭代
如果迭代的方法花了太久时间掌握以至于超出了你预期的学习截止日期，那么就舍弃，不要学。。

LC106从中序与后序遍历序列构造二叉树

和上面一样

class Solution {
    //unordered_map<int, int> index;
public:
    unordered_map<int, int> index;
    TreeNode* helper(vector<int>& inorder, vector<int>& postorder, int in_left, int in_right, int po_left, int po_right){
        if(in_left>in_right) return nullptr;
        int root_in=index[postorder[po_right]];//root在inorder的位置
        int left_size=root_in-in_left;//左子的长度
        TreeNode* root=new TreeNode(inorder[root_in]);
        root->left=helper(inorder, postorder, in_left, root_in-1, po_left, po_left+left_size-1);
        root->right=helper(inorder, postorder, root_in+1, in_right, po_left+left_size, po_right-1);
        return root;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        //思路和中序+前序一样
        int n=inorder.size();
        if(n==0) return nullptr;
        for(int i=0; i<n; ++i){
            index[inorder[i]]=i;
        }
        return helper(inorder, postorder, 0, n-1, 0, n-1);

    }
};