Leetcode算法题

多数元素

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

哈希表

我们使用哈希映射（HashMap）来存储每个元素以及出现的次数。
对于哈希映射中的每个键值对，键表示一个元素，值表示该元素出现的次数。

我们用一个循环遍历数组nums并将数组中的每个元素加入哈希映射中。
在遍历数组nums时候使用打擂台的方法，维护最大的值，这样省去了最后对哈希映射的遍历。

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        unordered_map<int, int> counts;
        for(int num:nums){
            counts[num]++;
            if(counts[num] > nums.size()/2){
                return num;
            }
        }
        return nums[0];
    }
};

排序

如果将数组nums中的所有元素按照单调递增或单调递减的顺序排列，那么下标n/2的元素一定是众数。

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        return nums[nums.size()/2];
    }
};

颠倒二进制位

颠倒给定的32位无符号整数的二进制位。

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        int array[32]={0};
        int i = 0;
        while(n){
            array[i++] = n%2;
            n = n/2;
        }
        uint32_t ret = 0;
        for(i=0; i<32; i++){
            ret += array[i]*pow(2,32-i-1);
        }
        return ret;
    }
};

找出美丽数组的最小和

需要构造一个大小为n的正整数数组，该数组由不同的数字组成，并且没有任意两个数字的和等于target，在满足这样的前提下，要保证数组的和最小。

为了让数组之和最小，我们按照1,2，3的顺序考虑，但添加了x之后，就不能添加taget-x，因此最大可以添加到target/2，如果个数不够，就继续从target，target+1，…依次添加，由于添加的数字是连续的，所以可以用等差数列求和公式快速求解。

存在重复元素二

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        int n = nums.size();
        for(int i=0; i<n; i++){
            for(int j=i+1; j<n; j++){
                if(nums[i] == nums[j] && abs(i-j) <= k){
                    return true;
                }
            }
        }
        return false;
    }
};

暴力求解超时

二叉搜索树的范围和

给定二叉搜索树的根结点 root，返回值位于范围 [low, high] 之间的所有结点的值的和。

class Solution {
public:
    void inOrder(TreeNode* root,vector<int>& nums){
        if(root == nullptr){
            return;
        }
        inOrder(root->left, nums);
        nums.push_back(root->val);
        inOrder(root->right, nums);
    }
    int rangeSumBST(TreeNode* root, int low, int high) {
        vector<int> nums;
        inOrder(root, nums);
        int sum = 0;
        for(int num:nums){
            if(num >= low && num <= high){
                sum += num;
            }
            else if(num > high){
                return sum;
            }
        }
        return sum;
    }
};

深度优先搜索

按深度优先搜索的顺序计算范围和。记当前子树根节点为root，分以下四种情况讨论：

1. root节点为空：返回0。
2. root节点的值大于high，无须考虑右子树。由于二叉搜索树右子树上所有节点的值均大于根节点的值，故无需考虑右子树，返回左子树的范围和。
3. root节点的值小于low。由于二叉搜索树左子树上所有节点的值均小于根节点的值，所以无需考虑左子树，返回右子树的范围和。
4. root的节点的值在[low,high]范围内。返回 root\textit{root}root 节点的值、左子树的范围和、右子树的范围和这三者之和。

广度优先搜索

使用广度优先搜索的方式，用一个队列q存储要计算的节点。每次去除队首节点时，若节点为空就跳过该节点。

Nim游戏

你和你的朋友，两个人一起玩 Nim 游戏：

• 桌子上有一堆石头。
• 你们轮流进行自己的回合， 你作为先手 。
• 每一回合，轮到的人拿掉 1 - 3 块石头。
• 拿掉最后一块石头的人就是获胜者。

假设每一步都是最优解。编写一个函数，判断是否可以在给定石头数量为n的情况下赢得游戏。
如果可以赢，返回true；否则，返回false。

找出不同元素数目差数组

给你一个下标从 0 开始的数组 nums ，数组长度为 n 。

afterSum = 3;

class Solution {
public:
    int count(vector<int>& nums,int i,int j){
        int array[51] = {0};
        int sum = 0;
        for(int k=i; k<=j; k++){
            if(array[nums[k]] == 0){
                sum++;
            }
            array[nums[k]]++;
        }
        return sum;
    }
    vector<int> distinctDifferenceArray(vector<int>& nums) {
        vector<int> res;
        int n = nums.size();
        for(int i=0; i<n; i++){
            int preSum = count(nums,0,i);
            int afterSum = count(nums,i+1,n-1);
            res.push_back(preSum-afterSum);
        }
        return res;
    }
};

猜数字游戏

你在和朋友一起玩 猜数字（Bulls and Cows）游戏，该游戏规则如下：

写出一个秘密数字，并请朋友猜这个数字是多少。朋友每猜测一次，你就会给他一个包含下述信息的提示：

• 猜测数字中有多少位属于数字和确切位置都猜对了（称为 “Bulls”，公牛），
• 有多少位属于数字猜对了但是位置不对（称为 “Cows”，奶牛）。也就是说，这次猜测中有多少位非公牛数字可以通过重新排列转换成公牛数字。

遍历

对于公牛，需要满足数字和确切位置都猜对。我们可以遍历secret和 guess，统计满足 secret[i] == guess[i] 的下标个数，即为公牛的个数。

对于奶牛，需要满足数字猜对但是位置不对。
可以统计在secre[i]≠guess[i]时