本文已参与「新人创作礼」活动，一起开启掘金创作之路

217. 存在重复元素

LeetCode: 217. 存在重复元素题目：给定一个整数数组，判断是否存在重复元素。
如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。示例 1:

输入: [1,2,3,1]
输出: true
示例 2:

输入: [1,2,3,4]
输出: false
示例 3:

输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

方法一：

对数组进行排序之后，相等的元素就会相邻。因此判断相邻的两个元素是否相等即可

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

代码解读：

Sort函数有三个参数：

（1）第一个是要排序的数组的起始地址。

（2）第二个是结束的地址（最后一位要排序的地址）

（3）第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序

less<数据类型>()//从小到大排序

greater<数据类型>()//从大到小排序

vector＜int＞& nums和vector＜int＞ nums的区别

带&表示传入函数的是vector的引用（即物理位置），函数内部对vector改动，vector就会改变；
不带&表示传入的是vector的复制品（开辟了另一块位置），函数内部对其改动，不会影响原本的vector；

参考：stackoverflow.com/questions/6…

结果：

挺拉的结果，可能是低级想法

方法二：哈希表

对于数组中的每个元素，先判断该元素是否在哈希表内。如果在的话就说明重复了，返回假值；如果不在，就放入哈希表，并继续往后找。

#include <unordered_set>
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> st;
        for (const int x:nums )
        {
            if (st.find(x) != st.end())
                return true;
            st.insert(x);
        }
        return false;
}
};

代码解读

1.unordered_set<int> st: 创建空的st
unordered_set 容器，可直译为“无序 set 容器”。即 unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会

2.for (const int num:nums)
跟python类似的for循环——基于范围的for循环

3.st.find(num) != st.end()

如果find的结果不等于end
就说明找到了 相当于返回有效的下标
如果等于end就相当于没找到 end相当于一个不存在的下标


找数组里的数
比如：找3 数组里有3的话 就返回3的下标
 

4.st.insert(num)
是添加的意思，将st找到的值添加到num(数组中)，用于之后判断是不是再出现相同值！

结果：

53. 最大子序和 LeetCode: 53. 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：输入：nums = [1] 输出：1

示例 3：输入：nums = [5,4,-1,7,8] 输出：23

链接：leetcode-cn.com/problems/ma…

思路：

设数组dp，其中dp[i]就是以第i个元素为末尾的连续子数组的最大和。

接下来思考dp[i]如何求得。可以发现只有2种情况：第i个元素要么自己成为新的连续子数组的起始项，要么连上前一个元素所在的连续子数组。而影响抉择的因素则是nums[i]和dp[i-1]+nums[i]两者之间的最大值。如果前一段连续子数组的和加上自己反而比自己小，那么自己就成为新的子数组的首项。

由此，状态转移方程为

其中，dp[0]应为nums[0]，因为nums[0]是第一个子数组的末项。

不难给出一个时空复杂度皆为O(n)的实现。但是由状态转移方程可以发现，dp[i]只和dp[i-1]有关，那也就是说我们只要2个变量即可。变量pre用于维护dp[i-1]，每次通过pre=max(pre...)就可以实现状态转移。此外，变量ans用于存储最大和，这样空间复杂度就降为了O ( 1 )

相当于pre储存着从x1地方开始到x2的最大值，ans相当于每一小段和进行比较的最大值

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
            int pre = 0,ans = nums[0];
            for (const auto &x :nums)
            {
                pre = max(pre + x,x);
                ans = max(ans,pre);

            }
            return ans;
    }
};

heart_6662——【LeetCode学习计划】《数据结构入门-C++》第1天 数组打卡