【无标题】

26. 删除有序数组中的重复项
    给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
                int left = 0, right = 1, n = nums.size();
        while (right < n)
        {
            if (nums[right] == nums[left])
            {
                right++;
            }
            else
            {
                left++;
                nums[left] = nums[right];
                right++;
            }
        }
     return left + 1<n?left+1:n;

    }
};

快慢指针
283. 移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int left = -1, right = 0, n = nums.size(),n1=n;
        while (right < n)
        {
            if (nums[right] == 0)
            {
                right++;
            }
            else
            {
                left++;
                nums[left] = nums[right];
                right++;
            }
        }
        for (int i = left + 1; i < n; i++)
        {
            nums[i] = 0;
        }

    }
};

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

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (int& x : nums)
        {
            if (x < 0)
            {
                x = -x;
            }
        }
        sort(nums.begin(), nums.end());
        for (int& x : nums)
        {
            x = x * x;
        }
        return nums;
    }
};

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        
        int x_left,x_right;
        int left = 0, right = nums.size() - 1;
        x_left = nums[left] * nums[left];
        x_right = nums[right] * nums[right];
        int n = nums.size();
        int i = n-1;
        vector<int>ans(n);
        while (left <= right)
        {
            if (x_left > x_right)
            {
                ans[i]=x_left;
                left++;
                if (left < n)
                {
                    x_left = nums[left] * nums[left];

                }
                else
                {
                    break;
                }
                
                i--;
            }
            else
            {
                ans[i] =x_right;
                right--;
                if(right>=0)
                {
                    x_right = nums[right] * nums[right];
                }
                else
                {
                    break;
                }
                
               
                i--;
            }
        }
        return ans;
    }
};

利用双指针对数组进行排序，因为数组中的元素有正有负，所以在平方后找到最大值的方法，一定是在数组的两边，然后依次进行比较，把大的数放在存储数组中，然后继续遍历

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
       vector<int> ans;
      
        int len = nums.size();
         int neg=len;
        for (int i = 0; i < nums.size(); i++)
        {
            if (nums[i] >= 0)
            {
                neg = i;
                break;
            }
        }
        int negt = neg - 1, pos = neg;
        while (negt >= 0 && pos < len)
        {
            if (nums[negt]*nums[negt] < nums[pos]*nums[pos])
            {
                ans.push_back(nums[negt]*nums[negt]);
                negt--;
            }
            else
            {
                ans.push_back(nums[pos]*nums[pos]);
                pos++;
            }
        }
        if (negt == -1)
        {
            for (int i = pos; i < len; i++)
            {
                ans.push_back(nums[i] * nums[i]);
            }
        }
        if (pos == len)
        {
            for (int i = negt; i >=0; i--)
            {
                ans.push_back(nums[i] * nums[i]);
            }
        }
        return ans;
    }
};

209. 长度最小的子数组
     给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
  int n = nums.size();
        int ans = n; 
        int flag = 0;
        for (int i = 0; i < n; i++)
        {
            int sum = nums[i];
            if (sum >=s)
            {
                flag=1;
                ans = 1;
                break;
            }
            for (int j = i+1; j < n;j++ )
            {
                sum+=nums[j];
               if(sum >=s)
                {
                    flag = 1;
                    ans = (j-i+1)< ans ? (j-i+1):ans;
                    break;
                }
            }
        }
        if (flag == 1)
        {
            return ans;
        }
        else
        {
            return 0;
        }
    }
};

暴力解法

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        
        int ans= INT_MAX;
        int n = nums.size();
        vector<int>sums(n);
        int flag = 0;
        if (n == 0)
        {
            return 0;
        }
        else
        {
            sums[0] = nums[0];
            for (int i = 1; i < nums.size(); i++)
            {
                sums[i] = sums[i - 1] + nums[i];
            }
            
            for (int j = 0; j < n; j++)
            {
                int left = j, right = n - 1;
                while (left <= right)
                {
                    int middle = (left + right) / 2;
                    if (sums[middle] -sums[j]+nums[j]<target)
                    {
                        left = middle + 1;
                    }
                    else
                    {
                        flag = 1;
                        ans = ans < (middle - j + 1) ? ans : (middle - j + 1);
                        right = middle - 1;
                    }
                }
            }
            if (flag == 1)
            {
                return ans;
            }
            else
            {
                return 0;
            }
        }
        
    }
};