代码随想录算法训练营第一天 | 数组part01：数组理论基础，704. 二分查找，27. 移除元素 977.有序数组的平方-CSDN博客

本文链接：https://blog.csdn.net/qq_53992974/article/details/141648112

数组理论基础

数组的内存空间地址是连续的
数组不可删除和增加元素，只能通过覆盖来变换元素

704. 二分查找

题目描述

注意事项

二分查找的区间有两种，分别是左闭右闭、左闭右开。区间不同，查找的循环条件和区间收缩的边界也不同

左闭右闭：循环条件 while(left<=right) 、右边界收缩 right=mid-1;
左闭右开：循环条件 while(left<right) 、右边界收缩 right=mid;

代码

以下代码是使用了左闭右闭

#include<iostream>
#include<vector>

using namespace std;

int search(vector<int>& nums, int target) {
    int left=0,right=nums.size()-1;

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


int main(int argc,char** argv)
{
    vector<int> vec(n);
    int target;
    int res;
    for(auto& i:vec)
    {
        cin>>i;    
    }
    cin>>target;

    res=search(vec, int target);
    cout<<res<<endl;
    return 0;

}

题目练习

35. 搜索插入位置

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

34. 在排序数组中查找元素的第一个和最后一个位置

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

    int rightIndex(vector<int>& nums, int target)
    {
        int left=0;
        int right=nums.size()-1;
        while(left<=right)
        {
            int mid=left+(right-left)/2;
            if(nums[mid]>target)
            {
                right=mid-1;
            }
            else if(nums[mid]<=target)
            {
                left=mid+1;
            }
            
        }
        return nums[right]==target?right:-1;
    }
    vector<int> searchRange(vector<int>& nums, int target) {
        if (nums.empty()) {  
            return {-1, -1};  
        }
        if(target<nums[0]||target>nums.back())
        {
            return {-1,-1};
        }    
        int left=leftIndex(nums,target);
        int right=rightIndex(nums,target);
        return {left,right};
    }
};

69. x 的平方根

class Solution {
public:
    int mySqrt(int x) {
        int left=0,right=x;
        int res;
        while(left<=right)
        {
            int mid=left+(right-left)/2;
            long long mid2=pow(mid,2);
            if(mid2<x)
            {
                left=mid+1;
                res=mid;
            }
            else if(mid2>x)
            {
                right=mid-1;
                res=right;
            }
            else
            {
                return mid;
            }
        }
        return res;

    }
};

367. 有效的完全平方数

class Solution {
public:
    bool isPerfectSquare(int num) {
        int left=0,right=num;
        while(left<=right)
        {
            int mid=left+(right-left)/2;
            long long mid2=pow(mid,2);
            if(mid2<num)
            {
                left=mid+1;
            }
            else if(mid2>num)
            {
                right=mid-1;
            }
            else
            {
                return true;
            }
        }
        return false;
    }
};

27. 移除元素

题目描述

此题有两种解法，可用暴力解法和双指针解法，暴力解法通过两层循环更新数组，双指针解法即通过快指针遍历数组，慢指针通过判断条件更新数组

暴力解法

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

双指针解法

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

题目练习

26. 删除有序数组中的重复项

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow=0;
        
        for(int i=1;i<nums.size();i++)
        {
            if(nums[i]!=nums[slow])
            {
                slow++;
                nums[slow]=nums[i];
            }
        }
        return slow+1;
    }
};

283. 移动零

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow=0;
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]!=0)
            {
                nums[slow++]=nums[i];
            }
        }
        for(int i=slow;i<nums.size();i++)
        {
            nums[i]=0;
        }
    }
};

844. 比较含退格的字符串

class Solution {
public:
    int func(string &tmp)
    {
        int slow=-1;
        for(char c:tmp)
        {
            if(c=='#')
            {
                if(slow>-1)
                {
                    slow--;
                }
            }
            else
            {
                slow++;
                tmp[slow]=c;
            }
        }
        return slow;

    }

    bool backspaceCompare(string s, string t) {
        int s1=func(s);
        int s2=func(t);
        if(s1!=s2)
        {
            return false;
        }
        else
        {
            

            for(int i=0;i<=s1;i++ )
            {
                if(s[i]!=t[i])
                {
                    return false;
                }
            }
            return true;
        }
    }
};

977.有序数组的平方

class Solution {
public:

    vector<int> sortedSquares(vector<int>& nums) {
        for(auto& i:nums)
        {
            i=pow(i,2);
        }
        
        vector<int> res(nums.size());
        int i=0,j=nums.size()-1;
        int n=nums.size()-1;
        while(i<=j)
        {
            if(nums[i]<=nums[j])
            {
                res[n--]=nums[j];
                j--;
                
            }
            else
            {
                res[n--]=nums[i];
                i++;
            }
        }
        return res;


    }
};

注：其实这题用sort函数一行代码就搞定了，实现sort函数也可以直接用最简单的冒泡排序算法，但是复杂度就很高了

for(int i=0;i<size-1;i++)
{
    for(int j=0;j<size-1-i;j++)
    {
        if(nums[j]>nums[j+1])
             swap(nums[j],nums[j+1])
    }
    
}