leetcode 217. Contains Duplicate、219. Contains Duplicate II、220. Contains Duplicate、287. Find the Du...

后面3个题都是限制在1～n的，所有可以不先排序，可以利用巧方法做。最后两个题几乎一模一样。

 217. Contains Duplicate

可以通过排序然后判断相邻两个的数是否相等，时间复杂度O(nlogn),空间复杂度O(1)

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        int length = nums.size();
        if(length <= 0)
            return false;
        sort(nums.begin(),nums.end());
        for(int i = 1;i < length;i++){
            if(nums[i] == nums[i-1])
                return true;
        }
        return false;
    }
};

使用hash-map，时间复杂度时间复杂度O(n),空间复杂度O(n)

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_map<int,int> m;
        for(int i = 0;i < nums.size();i++){
            if(m.count(nums[i]) == 0)
                m[nums[i]] = 1;
            else
                return true;
        }
        return false;
    }
};

219. Contains Duplicate II

用hash存储数和index，如果大于了k，就以当前这个位置的index重新更新数所对应的位置索引

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

 

220. Contains Duplicate III

http://www.cnblogs.com/grandyang/p/4545261.html

要求两数的索引的绝对值小于k，数值差的绝对值小于t。

索引的绝对值小于k可以用一个滑动窗口来解决，即代码中的j是窗口的左边界，i是当前窗口右边界，一旦超过了k就移动左边界。

数值差的绝对值小于t相当于：|Ni - Nj| <= t，展开得到-t <= Ni - Nj <= t，继续变换得到Nj-t <= Ni <= Nj+t,最终得到Ni - t <= Nj <= Ni + t。

lower_bound是寻找第一个大于等于当前数的结果，也就是说找第一个满足下边界的Nj，lower_bound返回的是一个迭代器，如果能找到下边界的第一个，并且满足上边界就证明可以找到这么一个值。如果找到，但是不满足上边界，那证明当前的map中没有数可以满足上边界，因为这个数是最小的下边界数，不满足上边界则代表大于上边界，既然这个最小的都大于上边界，其他数也都大于上边界。这里的代码实际上是想实现判断是否满足上边界，只是写成了abs的形式。

map, set等数据结构是基于红黑树实现的，unordered_map和unordered_set是基于哈希表实现的，而stack和priority_queue分别是栈和堆，能用lower_bound的数据结构是map, set, 或者vector这样的容器。首先我们要知道lower_bound的实现是基于二分搜索法的，那么容器必须要有序，所以那些unordered什么的自然不能用了。

时间复杂度为nlogn，lower_bound时间复杂度为logn

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        map<long,int> m;
        int j = 0;
        for(int i = 0;i < nums.size();i++){
            if(i - j > k)
                m.erase(nums[j++]);
            auto it = m.lower_bound((long)nums[i] - t);
            if(it != m.end() && abs(nums[i] - it->first) <= t)
                return true;
            m[nums[i]] = i;
        }
        return false;
    }
};

 

 

 

 

287. Find the Duplicate Number

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int length = nums.size();
        if(length <= 0)
            return -1;
        int start = 1;
        int end = length - 1;
        while(start < end){
            int mid = (start + end)/2;
            int count = 0;
            for(int i = 0;i < length;i++){
                if(nums[i] <= mid)
                    count++;
            }
            if(count > mid)
                end = mid;
            else
                start = mid + 1;
        }
        return start;
    }
};

http://www.cnblogs.com/grandyang/p/4843654.html

https://blog.csdn.net/xudli/article/details/48802345

https://segmentfault.com/a/1190000003817671

442. Find All Duplicates in an Array

注意比的时候要i+1，因为数值比坐标大

class Solution {
public:
    vector<int> findDuplicates(vector<int>& nums) {
        vector<int> result;
        int length = nums.size();
        if(length <= 0)
            return result;
        for(int i = 0;i < length;i++){
            if(nums[i] != nums[nums[i] - 1]){
                swap(nums[i],nums[nums[i]-1]);
                i--;
            }
        }
        for(int i = 0;i < length;i++){
            if(nums[i] != i + 1)
                result.push_back(nums[i]);
        }
        return result;
    }
};

http://www.cnblogs.com/grandyang/p/6209746.html

448. Find All Numbers Disappeared in an Array

这个题与442的题代码几乎一模一样，只是result存储的是坐标+1，也就是具体的消失的数值

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        vector<int> result;
        int length = nums.size();
        for(int i = 0;i < length;i++){
            if(nums[i] != nums[nums[i]-1]){
                swap(nums[i],nums[nums[i]-1]);
                i--;
            }
        }
        for(int i = 0;i < length;i++){
            if(nums[i] != i+1)
                result.push_back(i+1);
        }
        return result;
    }
};

https://www.cnblogs.com/grandyang/p/6222149.html

 

转载于:https://www.cnblogs.com/ymjyqsx/p/9656954.html