leetcode专项面试题

leetcode 1367. 二叉树中的链表

class Solution {
public:
    bool judge(TreeNode *root, ListNode *head){
        if(head == nullptr) return true;
        if(root == nullptr) return false;
        if(root->val != head->val) return false;
        return judge(root->left, head->next) || judge(root->right, head->next);
    }
    bool isSubPath(ListNode* head, TreeNode* root) {
        if(head == nullptr) return true;
        if(root == nullptr) return false;
        if(root->val == head->val && judge(root, head)) return true;
        return isSubPath(head, root->left) || isSubPath(head, root->right);
    }
};

leetcode 958. 二叉树的完全性检验

class Solution {
public:
    int nodeCount(TreeNode *root){
        if(root == nullptr) return 0;
        return nodeCount(root->left) + nodeCount(root->right) + 1;
    }
    bool judge(TreeNode *root, int n ,int m){
        if(root == nullptr) return n == 0;
        if(n == 0) return false;
        if(n == 1) return root->left == nullptr && root->right == nullptr;
        int k = max(0, 2 * m - 1);
        int l = min(m, n - k), r = n - k - l;
        return judge(root->left, (k - 1) / 2 + l, m / 2) && judge(root->right, (k - 1) / 2 + r, m / 2);
    }
    bool isCompleteTree(TreeNode* root) {
        if(root == nullptr) return true;
        int n = nodeCount(root), m = 1, cnt = 1;
        while(cnt + 2 * m <= n){
            m *= 2;
            cnt += m;  
        }
        return judge(root, n, m);
    }
};

464. 我能赢吗

class Solution {
public:
    unordered_map<int, bool> h;
    bool dfs(int mask, int n, int total){
        if(h.find(mask) != h.end()) return h[mask];
        for(int i = 1; i <= n; i++){
            if(mask & (1 << i)) continue;
            if(i >= total || !dfs(mask | (1 << i), n, total - i)){
                return h[mask] = true;
            }
        }
        return h[mask] = false;
    }

    bool canIWin(int maxChoosableInteger, int desiredTotal) {
        int n = maxChoosableInteger, mask = 0;
        if((1 + n) * n / 2 < desiredTotal) return false;
        h.clear();
        return dfs(mask, maxChoosableInteger, desiredTotal);
    }
};

172. 阶乘后的零

class Solution {
public:
    int trailingZeroes(int n) {
        int m = 5, cnt = 0;
        while(n / m){
            cnt += n / m;
            m *= 5;
        }
        return cnt;
    }
};

384. 打乱数组

class Solution {
public:
    vector<int> nums;
    Solution(vector<int>& nums) : nums(nums) {
        srand(time(0));
    }
    
    vector<int> reset() {
        return nums;
    }
    
    vector<int> shuffle() {
        vector<int> ret(nums);
        for(int i = 0; i < ret.size(); i++){
            swap(ret[i], ret[rand() % ret.size()]);
        }
        return ret;
    }
};

437. 路径总和 III

class Solution {
public:
    unordered_map<long, long> h;
    long count(TreeNode *root, long sum, long targetSum){
        if(root == nullptr) return 0;
        sum += root->val;
        int ans = h[sum - targetSum];
        h[sum] += 1;
        ans += count(root->left, sum, targetSum);
        ans += count(root->right, sum, targetSum);
        h[sum] -= 1;
        return ans;
    }
    long pathSum(TreeNode* root, int targetSum) {
        h.clear();
        h[0] = 1;
        return count(root, 0, targetSum);
    }
};

395. 至少有 K 个重复字符的最长子串

class Solution {
public:
    int longestSubstring(string s, int k) {
        unordered_map<char, int> cnt;
        vector<int> splits;
        for(auto x: s) cnt[x] += 1;
        for(int i = 0; s[i]; ++i){
            if(cnt[s[i]] < k) splits.push_back(i);
        }
        splits.push_back(s.size());
        if(splits.size() == 1) return s.size();
        int pre = 0, ans = 0;
        for(auto p : splits){
            int len = p - pre;
            if(len >= k){
                ans = max(ans, longestSubstring(s.substr(pre, len), k));
            }
            pre = p + 1;
        }
        return ans;
    }
};

190. 颠倒二进制位

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        uint32_t ret = 0;
        for(uint32_t i = 0, j = 1, k = (1 << 31); i < 32; i++, j <<= 1, k >>= 1){
            if(n & j) ret |= k;
        }
        return ret;
    }
};

8. 字符串转换整数 (atoi)

class Solution {
public:
    int myAtoi(string s) {
        int flag = 1, max_pre = INT_MAX / 10, d = INT_MAX % 10, ind = 0, num = 0;
        while(s[ind] == ' ') ++ind;
        if(s[ind] == '-') flag = -1, ind += 1;
        else if(s[ind] == '+') ind += 1;
        for( ; s[ind]; ++ind){
            if(s[ind] < '0' || s[ind] > '9') break;
            if(num > max_pre || (num == max_pre && s[ind] - '0' > d)){
                if(flag > 0) return INT_MAX;
                return INT_MIN;
            }
            num = num * 10 + (s[ind] - '0');
        }
        return num * flag;
    }
};

380. O(1) 时间插入、删除和获取随机元素

• 哈希表配合动态数组使用
• 高级数据结构是使用低级数据结构拼凑得到，工作中要使用基础数据结构拼凑出高级的符合业务场景的数据结构

class RandomizedSet {
public:
    unordered_map<int, int> h;
    vector<int> arr;

    RandomizedSet() {
        srand(time(0));
    }
    
    bool insert(int val) {
        if(h.find(val) != h.end()) return false;
        h[val] = arr.size();
        arr.push_back(val);
        return true;
    }

    void swap_item(int i, int j){
        swap(arr[i], arr[j]);
        h[arr[i]] = i;
        h[arr[j]] = j;
        return;
    }
    
    bool remove(int val) {
        if(h.find(val) == h.end()) return false;
        int n = h[val], m = arr.size() - 1;
        swap_item(n, m);
        h.erase(h.find(val));
        arr.pop_back();
        return true;
    }
    
    int getRandom() {
        return arr[rand() % arr.size()];
    }
};

402. 移掉 K 位数字

class Solution {
public:
    string removeKdigits(string num, int k) {
        if(k >= num.size()) return "0";
        string ret;
        for(auto x: num){
            while(k && ret.size() && ret.back() > x) ret.pop_back(), k-= 1;
            ret.push_back(x);
        }
        if(k != 0) ret = ret.substr(0, ret.size() - k);
        int ind = 0;
        while(ret[ind] == '0') ++ind;
        ret = ret.substr(ind, ret.size());
        if(ret == "") ret = "0";
        return ret;
    }
};

316. 去除重复字母

class Solution {
public:
    string removeDuplicateLetters(string s) {
        string ret;
        unordered_map<char, int> cnt;
        for(auto x: s) cnt[x] += 1;
        unordered_set<char> h;
        for(auto x : s){
            if(h.find(x) == h.end()){
                while(ret.size() && cnt[ret.back()] && ret.back() > x) {
                    h.erase(h.find(ret.back()));
                    ret.pop_back();
                }
                h.insert(x);
                ret.push_back(x);
            }
            cnt[x] -= 1;
        }

        return ret;
    }
};