<LeetCode OJ> 217./219. Contains Duplicate (I / II)

Given an array of integers, find if the array contains any duplicates.

Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

第一种方法:set数据结构,count函数记录数是否出现过,耗时96ms

用数据结构set来做。由于他是红黑树为底层,所以查找某个元素时间浮渣度较低,而且set不同意同样元素出现

假设某个元素的count为0则。插入到set,假设不为0,return false

set的查找时间为O(lg(N))所以终于时间浮渣度为O(Nlg(N))

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

或者set直接查找,100ms:

//思路首先:set查找
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        set<int> st;
        //for (auto i : nums) {
        for(int i=0;i<nums.size();i++)
         {
              if (st.find(nums[i]) != st.end())
                    return true;
              st.insert(nums[i]);
         }
        return false;
    }
};  

另外一种方法:map数据结构,count函数记录数是否出现过。96ms

//思路首先:
//既然能够用set来做,那么map来做也是能够的
//由于map不同意关键值反复(但实值能够),道理和set一样,都是红黑树为底层,本方法96ms完毕測试案例
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        if(nums.empty())
            return false;
        map<int, int> mapping;
        for (int i = 0; i<nums.size(); i++) {
            if(mapping.count(nums[i]))//假设该数出现过
                return true;
            mapping.insert(pair<int, int>(nums[i], i));//将nums[i]存储为关键值,实值在这里无所谓
        }
        return false;
    }
};

或者map直接查找,100ms:

//思路首先:map查找
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        if(nums.empty())
            return false;
        map<int, int> mapping;
        for (int i = 0; i<nums.size(); i++) {
            if(mapping.find(nums[i]) != mapping.end())//查找该数是否出现过
                return true;
            mapping.insert(pair<int, int>(nums[i], i));//将nums[i]存储为关键值,实值在这里无所谓
        }
        return false;
    }
};

第三种方法:先排序,再遍历一遍。检查数是否出现过。40ms

//思路首先:先排序。再遍历一遍是否有同样值。所以终于时间浮渣度为O(Nlg(N)+N),本方法40ms完毕測试案例
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
    if(nums.empty())
        return false;
    sort(nums.begin(), nums.end());
    for (int i = 1; i < nums.size(); i++) {
        if (nums[i-1] == nums[i])
            return true;
    }
    return false;
    }
};

第四种方法:哈希法。检查数是否出现过。48ms

//思路首先:hash法
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> hashset;
        //for (auto i : nums) {
        for(int i=0;i<nums.size();i++)
         {
              if (hashset.find(nums[i]) != hashset.end())
                    return true;
              hashset.insert(nums[i]);
         }
        return false;
    }
};  

有一个数组和一个整数,推断数组中是否存在两个同样的元素相距小于给定整数k。若是则返回真。

Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the difference between i and jis at most k.

分析:

哈希map(不要用红黑树map)

遍历数组。首先看当前元素是否在map中。如不在则压入,若在看是否其相应下标和当前下标相距为k

假设不则将原元素改动为如今的下标

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        if(nums.empty())
            return false;
        unordered_map<int,int> umapping;
        umapping[nums[0]]=0;
        for(int i=1;i<nums.size();i++)
        {
            //if(umapping.count(nums[i]) == 0)//没有出现(统计函数)
            if(umapping.find(nums[i]) == umapping.end())//直接查找
                umapping[nums[i]]=i;
            else if((i-umapping[nums[i]])<=k)//相距小于k
                return true;
            else
                umapping[nums[i]]=i;
        }
        return false;
    }
};  

注:本博文为EbowTang原创。兴许可能继续更新本文。

假设转载,请务必复制本条信息。

原文地址:http://blog.csdn.net/ebowtang/article/details/50443891

原作者博客:http://blog.csdn.net/ebowtang

时间: 2024-09-28 22:28:26

&lt;LeetCode OJ&gt; 217./219. Contains Duplicate (I / II)的相关文章

LeetCode OJ:Pascal&#39;s TriangleII(帕斯卡三角II)

Given an index k, return the kth row of the Pascal's triangle. For example, given k = 3,Return [1,3,3,1]. 还是帕斯卡三角,只不过这里指定的是某一个特定的层,然后直接返回,这个就可以使用从后往前更新数组的方法,其实I也可以用这个方法来做的,只不过当时没想到啊,代码如下: 1 class Solution { 2 public: 3 vector<int> getRow(int rowInde

LeetCode OJ:Search in Rotated Sorted Array II(翻转排序数组的查找)

Follow up for "Search in Rotated Sorted Array":What if duplicates are allowed? Would this affect the run-time complexity? How and why? Write a function to determine if a given target is in the array. 这个和前面的一个不一样就在于可能会有重复的数字,那么判断的时候就应该注意了,遇到start

LeetCode OJ:Remove Duplicates from Sorted List II(链表去重II)

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. For example,Given 1->2->3->3->4->4->5, return 1->2->5.Given 1->1->1->2->3, return 2->3.

LeetCode OJ 107. Binary Tree Level Order Traversal II

Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root). For example:Given binary tree {3,9,20,#,#,15,7}, 3 / 9 20 / 15 7 return its bottom-up level order traver

LeetCode OJ 82. Remove Duplicates from Sorted List II

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. For example,Given 1->2->3->3->4->4->5, return 1->2->5.Given 1->1->1->2->3, return 2->3.

leetCode 219. Contains Duplicate II 数组

219. Contains Duplicate II Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j]and the difference between i and j is at most k. 题目大意: 找到数组中两个相同元素,如果这两个元素的距离小于等于k

LeetCode OJ - Word Ladder 2

我发现在leetcode上做题,当我出现TLE问题时,往往是代码有漏洞,有些条件没有考虑到,这道题又验证了我这一想法. 这道题是在上一道的基础上进一步把所有可能得转换序列给出. 同样的先是BFS,与此同时需要一个hashMap记录下每个节点,和他所有父节点的对应关系,然后通过DFS,回溯所有可能的路径. 下面是AC代码. 1 /** 2 * Given two words (start and end), and a dictionary, find all shortest transform

LeetCode OJ - Sum Root to Leaf Numbers

这道题也很简单,只要把二叉树按照宽度优先的策略遍历一遍,就可以解决问题,采用递归方法越是简单. 下面是AC代码: 1 /** 2 * Sum Root to Leaf Numbers 3 * 采用递归的方法,宽度遍历 4 */ 5 int result=0; 6 public int sumNumbers(TreeNode root){ 7 8 bFSearch(root,0); 9 return result; 10 } 11 private void bFSearch(TreeNode ro

LeetCode OJ - Longest Consecutive Sequence

这道题中要求时间复杂度为O(n),首先我们可以知道的是,如果先对数组排序再计算其最长连续序列的时间复杂度是O(nlogn),所以不能用排序的方法.我一开始想是不是应该用动态规划来解,发现其并不符合动态规划的特征.最后采用类似于LRU_Cache中出现的数据结构(集快速查询和顺序遍历两大优点于一身)来解决问题.具体来说其数据结构是HashMap<Integer,LNode>,key是数组中的元素,所有连续的元素可以通过LNode的next指针相连起来. 总体思路是,顺序遍历输入的数组元素,对每个