数据结构学习计划W1

会分享一些正在做的经典习题及解法，如果有兴趣的话会写一下自己的理解。如果有感兴趣的朋友可以参考一下。

存在重复元素

给定一个整数数组，判断是否存在重复元素。
如果存在一值在数组中出现至少两次，函数返回 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

官方答案：

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

我自己写的时候把if(nums[i+1] == nums[i])改成了if(nums[i] == nums[i-1]),就直接报错
Line 1034: Char 34: runtime error: addition of unsigned offset to 0x602000000090 overflowed to 0x60200000008c (stl_vector.h)
想了一下这样写其实有问题，第0位的元素前面没有其他的元素比较。

最大子序和

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

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

示例2：

输入：nums = [1]
输出：1

示例3：

	输入：nums = [0]
	输出：0

示例4：

输入：nums = [-1]
输出：-1

示例5：

输入：nums = [-100000]
输出：-100000

本篇文章主要讨论一下贪心法求解这个问题：
贪心算法的思想：若当前指针所指元素的和小于0，则抛弃该指针之前的元素。

我们可以利用画图的方式，初步断定最大和为6，最大和子序为[4，-1，2，1]。
以下为代码实现

	class Solution {
public:
    int maxSubArray(vector<int>& nums) {
       int result = nums[0];  /初始化最大和为nums数组的第一个元素
       int sum = 0;	/初始化当前和，在本题中0也是sum值的最小边界
       int numsize = nums.size();  /得到nums数组的大小
       for( int i = 0; i<numsize; i++){ 
           sum+= nums[i];
           result =max(result, sum);  /比较当前sum值与最大值result选最大值
           if(sum<0)
           {
               sum = 0; /sum值小于0，直接抛弃
           }
       }
    return result;
   }
};

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

爷的水平也就只够做出来第一题💔。
但是还是用了两次遍历，时间复杂度食O(n^2)。因为题目比较简单，就不过多展开了。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
       int n = nums.size();
        for(int i = 0; i < n-1; i++)
        {
            for(int j = i+1; j< n; j++){
                if(nums[i] + nums[j] == target)
                {
                   return {i, j};
                }
            }
        }
        return {};
    }
};

合并两个有序数组

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。

初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。
这道题其实也不难，因为题目中已经假设nums1的空间是有n+m的，这样直接将num2的元素直接插入num1再排序即可。
具体实现代码如下

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
                for(int i =0; i<= n-1; i++)
                {
                    nums1[m+i] = nums2[i];
                }
        sort(nums1.begin(), nums1.end());
    }
};

ps：做完题顺便读了下力扣的机器学习101，感觉真没啥用23333。

两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。
示例1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
我们可以不考虑输出结果的顺序。
代码实现如下：

	class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> num;
        sort(nums1.begin(), nums1.end());
        sort(nums2.begin(), nums2.end());
        int length1 = nums1.size();
        int length2 = nums2.size();
        int index1 = 0, index2 = 0;
        while(index1 < length1 && index2 < length2)
        {
            if(nums1[index1]< nums2[index2])
            {
                index1++;
            }
            else if(nums1[index1]> nums2[index2])
            {
                index2++;
            }
            else {
                num.push_back(nums1[index1]);
                index1++;
                index2++;
            }
        }
        return num;
    }
};

力扣里面使用了两种方法，分别是哈希表和双指针。我在解题的时候是采用了双指针的写法。解释一下其实就是先排序，然后谁小谁先跑。