追随Carl（1）

1.力扣704（二分法）

int search(int* nums, int numsSize, int target){
     int left = 0;//左边界
     int right = numsSize;//右边界
     int middle;
     while(left<=right)
     {
     middle=(right+left)/2;//中间值
     if(nums[middle]>target)
     right=middle-1;//如果中间值大于目标值，结果一定在中间值的左边
     else if(nums[middle]<target)
     left=middle+1;//如果中间值小于目标值，结果一定在中间值的右边
     else  return middle;//不大于不小于就是相等，返回下标
     }
     return -1;//跳出循环都没有相等，返回-1
}

2.力扣1（两数相加）

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    std::unordered_map<int,int>map;//定义unordered_map，时间复杂度o(1)
    for(int i=0;i<nums.size();i++)
    {
        auto it=map.find(target-nums[i]);//向前寻找使两数相加等于target的值
        if(it!=map.end())
        return {it->second,i};//找到返回
        map.insert(pair<int,int>(nums[i],i));//否则插入供后来寻找
    }
    return {};//没有找到返回空
    }
};

C语言暴力解
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int i,j;
    int *result=NULL;//结果
   *returnSize=2;
    for(i=0;i<numsSize-1;i++)
    {
        for(j=i+1;j<numsSize;j++)
        {
            if(nums[i]+nums[j]==target)
            {
                 result=(int*)malloc(sizeof(int)*2);
                 result[0]=i;
                 result[1]=j;
                 return result;
            }
        }
    }
    return result;
}

3.力扣27（移除元素）

int removeElement(int* nums, int numsSize, int val){
  int i=0;
  int j=0;
    for(i=0;i<numsSize;i++)
    {
           if(nums[i]!=val)
           {
               nums[j]=nums[i];
               j++;
           }           
    }
    return j;
}

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
    int i=0; int j=0;
    for(i=0;i<nums.size();i++)
    {
           if(nums[i]!=val)
           {
               nums[j]=nums[i];
               j++;
           }

    }
    return j;
    }
};

4.力扣977（有序数组的平方）

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size());//结果数组，大小为原数组大小
        int i=0;int j=nums.size()-1;//双指针，一个在开头，一个在结尾，因为平方的最大值一定在两端，
平方数组先减小在增大，边界为：第一个正数或最后一个负数
        for(int k=nums.size()-1;k>=0;k--)//从后往前，从大到小填写结果数组
        {
        if(nums[i]*nums[i]<nums[j]*nums[j])
        {
            result[k]=nums[j]*nums[j]; //大指针大就填大指针，然后前移
            j--;  
        }
        else {
           result[k]=nums[i]*nums[i];//小指针大就填小指针，然后后移
           i++;
             }
        }
        return result;//返回结果数组
    }
};

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize){
          int *result = malloc(sizeof(int)*numsSize);//返回数组
          *returnSize=numsSize;//返回数组的大小
          int i=0;int j=numsSize-1;int k=numsSize-1;
          for(;k>=0;k--)//控制循环次数
          {
              if(nums[i]*nums[i]<nums[j]*nums[j])
              {
                  result[k]=nums[j]*nums[j];
                  j--;
              }
              else {
                  result[k]=nums[i]*nums[i];
                  i++;
                   }
          }
    return result;
}

5.力扣209（最小数组）

int minSubArrayLen(int target, int* nums, int numsSize){//滑动窗口
    int i=0,j=0,min=numsSize,sum=0,length,flag=0;//i序列起始，j序列末尾，min最后返回值（最大为//numsSize），sum所求序列长度和，length所求序列长度，flag标记位（判断是否有大于等于target的序列，有的话返回长度没有的话返回0）
    for(j=0;j<numsSize;j++)//j表示窗口的末尾
    {
        sum=sum+nums[j];
        while(sum>=target)//一旦遇到大于等于target的序列，i就要缩了
        {
            flag=1;//标记位，表示存在大于等于target的序列
            length=j-i+1;//计算序列长度
            min=(length<min)?length:min;//更新最小值
            sum=sum-nums[i];//i缩小
            i++;
        }
    }
    if(flag)//（判断是否有大于等于target的序列，有的话返回长度没有的话返回0）
    return min;
    else return 0;
}

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

6.力扣59（螺旋矩阵）

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
    vector<vector<int>> a(n,vector<int>(n,0));//初始化二维数组，n行，n列，初值全为0
       int startx=0,starty=0,count=1,m=1;//每次从一个点开始，循环一周，第一次为（0，0），count为填充数值
       int i,j;//a[i][j]
        for(int k=0;k<n/2;k++)
        {  //四次for循环，每次从开始到该行或该列的倒数第二个元素
            for(j=starty,i=startx;j<n-m;j++)
            a[i][j]=count++;
            for(;i<n-m;i++)
            a[i][j]=count++;
            for(;j>starty;j--)
            a[i][j]=count++;
            for(;i>startx;i--)
            a[i][j]=count++;
            startx++;
            starty++;
            m++;
        }
        if(n%2==1)//输入为3或5等奇数时，最中间的数要填充
        a[startx][starty]=count;
        return a;
    }
};