LeetCode刷数据结构例题

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

//用map映射保存每次出现过的元素
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {

        map<int,int>mp;

        for(int i=0;i<nums.size();i++){
            if(mp.find(nums[i])==mp.end()){
                mp[nums[i]]=1;
            }else{
                return true;
            }
        }

        return false;
    }
};

---

---

---

给定一个整数数组 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

//贪心算法，也可用动态规划做
//前面元素和为负数就丢掉
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        
        int maxn=nums[0],sum=nums[0];

        for(int i=1;i<nums.size();i++){
            if(sum<0){
                sum=nums[i];
            }else{
                sum+=nums[i];
            }
            maxn=max(sum,maxn);
        }
        return maxn;
    }
};

---

---

---

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：
你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

class Solution {
public:
    int search(vector<int>& nums, int target) { 
     
        int low=0,high=nums.size()-1;
        while(low<=high){          
            int mid=low+(high-low)/2;
            if(target==nums[mid]){
                return mid;
            }else if(target>nums[mid]){
               low=mid+1;
            }else{
                high=mid-1;
            }
        }
            return -1;
   }
};

---

---

---

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。 假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。 你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例 1：
输入：n = 5, bad = 4
输出：4
解释：
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。

示例 2：
输入：n = 1, bad = 1
输出：1

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        
        int left=0,right=n;

        while(left!=right){

            int mid=left+(right-left)/2;

            if(isBadVersion(mid)){
                right=mid;
            }else{
                left=mid+1;
            }
        
        }
        return left;

    }
};

---

---

---

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 请必须使用时间复杂度为 O(log n) 的算法。

示例 1:
输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:
输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:
输入: nums = [1,3,5,6], target = 7
输出: 4

示例 4:
输入: nums = [1,3,5,6], target = 0
输出: 0

示例 5:
输入: nums = [1], target = 0
输出: 0

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {

            int left=0,right=nums.size()-1;
            int mid;

            while(left<=right){
                
                mid=left+(right-left)/2;

                if(target==nums[mid]){
                    return mid;
                }else if(target>nums[mid]){
                    left=mid+1;
                }else{
                    right=mid-1;
                }

            }

            if(target>nums[mid]){
                return mid+1;
            }else{
                return mid;
            }

    }
};

---

---

---

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

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

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

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]

//也可以用map做，效率会更高
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int>v;
        for(int i=0;i<nums.size()-1;i++){
            for(int j=i+1;j<nums.size();j++){
                if(nums[i]+nums[j]==target){
                    v.push_back(i);
                    v.push_back(j);
                }
            }
        }
        return v;

    }
};

---

---

---

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

初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。

示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]

示例 2：
输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]

//双指针
class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
            int i=m+n-1;
            int j=m-1;
            int k=n-1;

            while(j>=0&&k>=0){
                if(nums1[j]<=nums2[k]){
                    nums1[i]=nums2[k];
                    i--;
                    k--;
                }else{
                    nums1[i]=nums1[j];
                    i--;
                    j--;
                }
            }
            
            for(int l=0;l<=k;l++){
                nums1[l]=nums2[l];
            }
    }
};

---

---

---

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

//用双指针做时间复杂度会更低
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
            vector<int>v;
            for(int i=0;i<nums.size();i++){
                int t=nums[i]*nums[i];
                v.push_back(nums[i]*nums[i]);
            }

            sort(v.begin(),v.end());
            return v;
    }
};

---

---

---

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

进阶：

尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

示例 1:
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

示例 2:
输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]

//用双指针会使空间复杂度更低，降到O(1)
class Solution {
public:
    void rotate(vector<int>& nums, int k) {
            int n=nums.size();
            vector<int>v(n);
            for(int i=0;i<n;i++){
                v[(i+k)%n]=nums[i];
            }

            for(int i=0;i<n;i++){
                nums[i]=v[i];
            }
    }
};