2021_01_22 LeetCode刷题

700. 二叉搜索树中的搜索

递归模拟题。根据二叉搜索树的性质，如果当前根节点为空，则直接返回空，如果当前值等于目标值，则直接返回该节点即可，如果当前值小于目标值，则递归遍历左子树，否则递归遍历右子树即可。

/**
 * 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:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root == nullptr)
            return nullptr;
        if(root->val == val)
            return root;
        if(val < root->val)
            return searchBST(root->left, val);
        return searchBST(root->right, val);
    }
};

703. 数据流中的第 K 大元素

最小堆或者可以模拟。模拟的思路是首先用一个数组存放所有的按从小到大排好序的元素，每次添加元素时，遍历数组，找到当前元素应该放置的位置，将该元素放置进去，得到完整的数组。之后根据下标找到最后的结果即可。

class KthLargest {
public:
    int num1[20011] = {0};
    int length = 0, k1 = 0;
    KthLargest(int k, vector<int>& nums) {
        k1 = k,length = nums.size();
        sort(nums.begin(),nums.end());
        for(int i = 0; i < length; i++)
            num1[i] = nums[i];
    }
    
    int add(int val) {
        bool flag = false;
        for(int i = 0; i < length; i++) {
            if(val < num1[i]) {
                for(int j = length; j > i; j--)
                    num1[j] = num1[j-1];
                length += 1;
                num1[i] = val;
                flag = true;
                break;
            }
        }
        if(!flag)
            num1[length] = val, length += 1;
        return num1[length - k1];
    }
};

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest* obj = new KthLargest(k, nums);
 * int param_1 = obj->add(val);
 */

705. 设计哈希集合

利用类似于桶排序的思想，使用布尔数组代替哈希表实现相应操作即可。

class MyHashSet {
public:
    /** Initialize your data structure here. */
    bool num1[1000010] = {false};
    MyHashSet() {
        memset(num1,sizeof(num1),false);
    }
    
    void add(int key) {
        num1[key] = true;
    }
    
    void remove(int key) {
        if(num1[key] == true)
            num1[key] = false;
    }
    
    /** Returns true if this set contains the specified element */
    bool contains(int key) {
        return num1[key];
    }
};

/**
 * Your MyHashSet object will be instantiated and called as such:
 * MyHashSet* obj = new MyHashSet();
 * obj->add(key);
 * obj->remove(key);
 * bool param_3 = obj->contains(key);
 */

704. 二分查找

如题，二分搜索题。直接写二分搜索即可。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int begin1 = 0, end1 = nums.size() - 1;
        int ans = -1;
        while(begin1 <= end1) {
            int mid1 = (begin1 + end1) / 2;
            if(nums[mid1] == target) {
                ans = mid1;
                break;
            } 
            if(nums[mid1] > target)
                end1 = mid1 - 1;
            else
                begin1 = mid1 + 1;
        }
        return ans;
    }
};