《代码随想录》3——数组

最新推荐文章于 2024-07-04 11:10:43 发布

猪小铭

最新推荐文章于 2024-07-04 11:10:43 发布

阅读量97

点赞数 12

文章标签： c++ c语言数据结构算法

本文链接：https://blog.csdn.net/m0_64340340/article/details/130119058

版权

数组是一种较为基本的数据结构，是存储在连续存储空间中具有相同数据类型的数据的集合

注意：1.数组的下标是从0开始

2.数组在内存空间的地址是连续的

3.数组的数据只能覆盖，不能删除

在c++中二维数组的存储空间地址也是连续的

1.二分查找

lc704.二分查找

在一个有序(升序)，无重复数组nums中查找target值

写法1：规定中分区间为左闭右闭

class Solution{
public:
    int search(vector<int>&nums,int target)
    {
        int left=0;                //初始化左指针
        int right=nums.size()-1;   //初始化右指针，数组下标最大为数组长度-1
        while(left<=right)         //规定中分区间左闭右闭
        {
            
            int mid=(left+right)/2;  //每次循环后更新mid值

            if(nums[mid]==target)return mid;

            else if(nums[mid]<target)
            {
                left=mid+1;

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

                }
            
           }
            return -1;  //查找后无返回值说明数组中不存在target返回-1
    }
};

写法2：规定中分区间为左闭右开

class Solution{
public:
    int search(vector<int>&nums,int target)
    {
        int left=0;
        int right=nums.size()-1;
        while(left<right)        //规定中分区间为左闭右开
        {
            int mid;
            mid=(left+right)/2;
            
            if(nums[mid]==target)return mid;
            
            else if(nums[mid]<target)
            {
                left=mid+1;
                }
            else if(nums[mid]>target)
            {
                right=mid;
                    }
            
           }
        if(left==right&&nums[left]==target) //需要特殊考虑left=right的情况
            {
                return left;                
                    }
            return -1;
        }
};

2.移除元素

lc27.移除元素

思路：数组中的元素只能覆盖，不能移除

暴力解法：当数组中存在val值时需要将后面所有元素向前移动一位，再从新的起始位置检查

时间复杂度O( $n^{2}$ )

快慢指针法：时间复杂度O(n)

class Solution{
public:
    int removeElement(vector<int>&nums,int val)
    {
        int slow=0;
        for(int fast=0;fast<nums.size();fast++) //用快指针遍历数组
        {
            if(nums[fast]!=val)
            {
                nums[slow]=nums[fast];  //用快指针为以慢指针为下表的数组赋值
                slow++;
                }
            }
        return slow;
        }
};

3.长度最小的子数组

lc209.长度最小的子数组

思路：

暴力解法：两层循环枚举所有子数组的组合与target比较，找出最小的子数组长度，时间复杂度

O( $n^{2}$ )

滑动窗口法:时间复杂度O(n)

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
            int result=INT32_MAX;   //初始化将结果定义为int类型最大数字
            int sublength=0;        //初始化子数组长度
            int i=0;                //设定起始位置
            int sum=0;              //初始化子数组之和 
           for(int j=0;j<nums.size();j++)
           {
               sum=sum+nums[j];
               while(sum>=target)
               {
                   sublength=j-i+1;  //子数组长度

                   if(result>sublength)result=sublength; 
                    //此时长度为sublength的子数组已满足条件，只需检验是否还有更小的sublength
                   
                    sum=sum-nums[i];  //滑动窗口，不断缩小子数组长度检验是否满足条件
                       i++;           //更新起始位置
               }    
           }
           if(result==INT32_MAX)return 0;
           else return result;
    }
};

4.螺旋矩阵

lc59.螺旋矩阵

思路：规定每次赋值都是左闭右开

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int startx=0;            //起始横坐标
        int starty=0;            //起始纵坐标
        int loop=n/2;            //圈数
        int mid=n/2;
        int floor=1;             //层数
        int count=1;             //二维数组赋值
        int i,j;
        vector<vector<int>>result(n,vector<int>(n,'.')); //初始化二维动态数组
        
        if(n%2==1)result[mid][mid]=n*n; //当n为奇数时需单独为最中间的元素赋值
        
        while(loop)
        {
            for(j=starty;j<n-floor;j++)
            {
                result[startx][j]=count;
                count++;
                    }
            for(i=startx;i<n-floor;i++)
            {
                result[i][j]=count;
                count++;
                    }
            for(;j>starty;j--)
            {
                result[i][j]=count;
                count++;
                    }
            for(;i>startx;i--)
            {
                result[i][j]=count;
                count++;
                    }
            startx++;  //下一圈时起始横坐标+1
            starty++;  //下一圈时起始纵坐标+1
            loop--;    //圈数-1
            floor++;   //层数+1
           }
        return result;

    }
};