剑指Offer-Week6

68. 0到n-1中缺失的数字

https://www.acwing.com/problem/content/64/
思路:

class Solution {
public:
    int getMissingNumber(vector<int>& nums) {
        int l = 0,r = nums.size();
        if(r == 0){
            return 0;
        }
        int ans = 0;
        //二分查找第一个nums[i]!=i的下标
        while(l < r){
            int mid = (l + r) >> 1;
            if(nums[mid] == mid){
                l = mid + 1;
            }
            else {
                r = mid;
            }
        }
        return l;
    }
};

69. 数组中数值和下标相等的元素

https://www.acwing.com/problem/content/65/
也是二分思路

class Solution {
public:
    int getNumberSameAsIndex(vector<int>& nums) {
        int l = 0,r = nums.size();
        if(r == 0){
            return -1;
        }
        while(l < r){
            int mid = (l + r) >> 1;
            if(nums[mid] < mid){
                l = mid +1;
            }
            else {
                r = mid;
            }
        }
        if(nums[l] != l) return -1;
        return l;
    }
};

70. 二叉搜索树的第k个结点

https://www.acwing.com/problem/content/submission/66/

class Solution {
public:
    TreeNode* kthNode(TreeNode* root, int k) {
        vector<TreeNode*>nums;
        dfs(root,nums);
        return nums[k-1];
    }
    void dfs(TreeNode* root,vector<TreeNode*> &nums){
        if(root -> left){
            dfs(root -> left,nums);
        }
        nums.push_back(root);
        if(root -> right){
            dfs(root -> right,nums);
        }
    }
};

71. 二叉树的深度

https://www.acwing.com/problem/content/67/

class Solution {
public:
    int maxn = INT_MIN;
    int treeDepth(TreeNode* root) {
        if(!root) return 0;
        dfs(root,1);
        return maxn;
    }
    void dfs(TreeNode* root,int x){
        maxn = max(maxn,x);
        if(root -> left){
            dfs(root -> left,x + 1);
        }
        if(root -> right){
            dfs(root -> right,x + 1);
        }
    }
};

72. 平衡二叉树

https://www.acwing.com/problem/content/68/

class Solution {
public:
    bool ans = true;
    bool isBalanced(TreeNode* root) {
        if(!root) return true;
        dfs(root);
        return ans;
    }
    int getHeight(TreeNode* root){
        if(!root) return 0;
        return max(getHeight(root -> left),getHeight(root -> right)) + 1;
    }
    void dfs(TreeNode* root){
        if(!ans) return ;
        if(!root) return ;
        int n1 = getHeight(root -> left);
        int n2 = getHeight(root -> right);
        if(abs(n1 - n2) > 1){
            ans = false;
            return ;
        }
        else {
            dfs(root -> left);
            dfs(root -> right);
        }
    }
};

73. 数组中只出现一次的两个数字

https://www.acwing.com/problem/content/69/
完全想不到:
假设答案为a,b 一轮^运算完结果为 a^b 然后根据a^b的二进制找一位为1的(假设第二位为1)
然后根据是否第二位为1 区分数组
a,b必非到不同组 因为两者^该位为1 说明不同 而其他数字由于都出现两个 必有两个相同的在一组
就变成分成两组 每组中只有一个不同的数字 那么直接一轮^运算即可得到结果

class Solution {
public:
    vector<int> findNumsAppearOnce(vector<int>& nums) {
        int sum = 0;
        for(int x : nums){
            sum ^= x;
        }
        int k = 0;
        while(!(sum >> k & 1)) k++;
        int first = 0;
        for(int x : nums){
            if(x >> k & 1){
                first ^=x;
            }
        }
        int second = sum ^ first;
        return vector<int>({first,second});
    }
};

75. 和为S的两个数字

https://www.acwing.com/problem/content/description/71/

class Solution {
public:
    vector<int> findNumbersWithSum(vector<int>& nums, int target) 
    {
        unordered_map<int, int> hash;//创建哈希表
        for (int i = 0; i < nums.size(); ++i) {
            if(hash[target - nums[i]] == 0)//如果哈希表中没有target - nums[i]
                hash[nums[i]]++;//nums[i]出现次数加1
            else//如果哈希表中有target - nums[i]
                return {nums[i], target - nums[i]};//返回答案
        }
        return {};

    }
};