数据结构--LeetCode专题练习 Day1

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

原始思路:

暴力求解，使用了两重循环：当第一重循环遍历到i时，第二重循环从第i+1个位置开始遍历寻找有无与第i个元素相同的元素。(没有通过，时间复杂度为O（n2）)

class Solution {
    public boolean containsDuplicate(int[] nums) {
        for(int i = 0; i < nums.length - 1; i++) {
            for(int j = i + 1; j < nums.length; j++) {
                if(nums[i] == nums[j]) {
                    return true;
                }
            }
        }
        return false;
    }
};

思路更正：

1.排序法

将数组中的数据进行排序，只需比较相邻两者即可（因为在排序时，若出现相等的数据必定是相邻的）时间复杂度为O（n）

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]==nums[i+1]){   //相邻两个比较
              return true; //不相等则代表不重复
          }
      }
      return false; //相等则代表重复
    }
};

2.哈希表

将数组中的数据依次存入hash表中，每次放入时都需与hash表内的数据进行比较，看看是否有重复。

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int>s;
        for(int x:nums){
            if(s.find(x)!=s.end()){  //比较是否在hash表中
                return true; //不在，返回true
            }
            s.insert(x);// 并将该数加入hash表
        }  
        return false;//该数字已经在hash表中存在，则返回false
    }
};

 

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 = [0]
输出：0
示例 4：

输入：nums = [-1]
输出：-1
示例 5：

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

提示：

1 <= nums.length <= 3 * 104
-105 <= nums[i] <= 105
 

原始思路：求出所有子序列，并进行求和

（思路看上去简单，但实际操作会十分复杂）

更正思路：

1.暴力法C++（不推荐，耗时过多）580ms   O(n2)

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
      int result=INT32_MIN;
      int count=0;
      for(int i=0;i<nums.size();i++){// 设置起始位置
          count=0;
          for(int j=i;j<nums.size();j++){ // 每次从起始位置i开始遍历寻找最大值
              count+=nums[j];
              result=count>result?count:result;
          }
      }
      return result;
    }
};//580 ms  12.8 MB

2.贪心算法

若当前指针所指元素之前的和<0,则丢弃当前元素之前的数列

我们需要清楚的知道每次执行中的四个变量：当前值、之前和、当前和、最大和。

（1）当之前和>0

比较当前和 与 之前和 得出 最大和

（2）当前和<0，舍去当前和

当前元素（即当前值）即为最大值

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
      int result=INT32_MIN;
      int count=0;
      for(int i=0;i<nums.size();i++){// 设置起始位置
         count+=nums[i];
         if(count>result){// 取区间累计的最大值（相当于不断确定最大子序终止位置）
             result=count;
         }
         if(count<=0) count=0; // 相当于重置最大子序起始位置，因为遇到负数一定是拉低总和
      }
      return result;
    }
};//8 ms 12.9 MB

2.动态规划算法

若前一个元素>0,则将其加到当前元素上

动态规划的思路（5steps）
1.确定dp数组（dp table）以及下标的含义
**dp[i]：包括下标i之前的最大连续子序列和为dp[i]**。
2.确定递推公式
dp[i]只有两个方向可以推出来：
~dp[i - 1] + nums[i]，即：nums[i]加入当前连续子序列和
~nums[i]，即：从头开始计算当前连续子序列和一定是取最大的，所以dp[i] = max(dp[i - 1] + nums[i], nums[i]);
3.dp数组如何初始化
从递推公式可以看出来dp[i]是依赖于dp[i - 1]的状态，dp[0]就是递推公式的基础。

（ dp[0]应该是多少呢?
    更具dp[i]的定义，很明显dp[0]因为为nums[0]即dp[0] = nums[0]。）

4.确定遍历顺序
递推公式中dp[i]依赖于dp[i - 1]的状态，需要从前向后遍历。

5.举例推导dp数组
以示例一为例，输入：nums = [-2,1,-3,4,-1,2,1,-5,4]，对应的dp状态如下： 

注意最后的结果可不是dp[nums.size() - 1] ，而是dp[6]。
dp[i]的定义：包括下标i之前的最大连续子序列和为dp[i]。
那么我们要找最大的连续子序列，就应该找每一个i为终点的连续最大子序列。
所以在递推公式的时候，可以直接选出最大的dp[i]。*/
 

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
     if(nums.size()==0) return 0;
     vector<int>dp(nums.size());
     dp[0]=nums[0];
     int result=dp[0];
     for(int i=1;i<nums.size();i++){
         dp[i]=max(dp[i-1]+nums[i],nums[i]);// 状态转移公式,比较出最大值
         if(dp[i]>result) result=dp[i];// result 保存dp[i]的最大值
        }
     return result;
    }
};//8 ms 13 MB