初级算法-数组

已于 2023-07-27 16:11:05 修改
阅读量219 收藏
点赞数
分类专栏： 力扣每日一题 文章标签： 算法 数据结构
于 2023-07-22 20:28:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fei_WuYan/article/details/131872263
版权
本文介绍了如何在排序数组中删除重复元素的原地算法，探讨了买卖股票获取最大利润的贪心策略，以及如何实现数组的整体旋转。同时，还讨论了判断数组是否存在重复元素、找到两个数组的交集和解决数学问题如加一、移动零、两数之和的有效方法。
摘要由CSDN通过智能技术生成

文章目录

数组：

删除排序数组中的重复项
题意：

一个升序数组nums，要求使用原地算法，要求返回数组内有几种数字

若有K种，需要保证原数组处理完[0,K-1]以原序存储每种数字各一个

解：

由于要求使用原地算法，所以直接对原数组操作，使用一个指针L表示所指向数字的第一个，默认指向0

遍历数组，如果遇到一个和指针L指向的数字不同的数字ElseNum，就将ElseNum放在L+1的位置，然后L指向ElseNum表示ElseNum这种数字已经找到了第一个，可以找下一种了

代码：
#include<bits/stdc++.h>
using namespace std;
int removeDuplicates(vector<int>& nums)
{
    int l=0,k=1,lg=nums.size();
    for(int i=1;i<lg;i++)
    {
        if(nums[i]!=nums[l])
        {
            swap(nums[i],nums[++l]);
            k++;
        }
    }
    return k;
}
int main()
{
    vector<int>nums;int temp;
    while(cin>>temp)
    {
        nums.push_back(temp);
    }
    int ans=removeDuplicates(nums);
    cout<<ans<<endl;
    return 0;
}
买卖股票的最佳时机 II
题意：

给定一个整数数组，代表每天的股票价格，最多只能持有一股，求最大利润

解：

贪心，有的赚先赚。任意两个数字[A,B]，A表示今天的价格，B表示你预知明天的价格，如果A<B，则明天涨价，那就在今天买明天卖；如果B<A，则明天跌落，今天先卖明天再买可以用更低的成本持有一股。

由于核心思路是通过看下一天的价格来考虑今天是否持有一股（初始没有持有），所以对任意一段求最大利润不需要依赖其他部分。

代码：
#include<bits/stdc++.h>
using namespace std;
int maxProfit(vector<int>& prices)
{
    int lg=prices.size(),ans=0;
    for(int i=1;i<lg;i++) ans=ans+max(0,prices[i]-prices[i-1]);
    return ans;
}
int main()
{
    vector<int>prices;int temp;
    while(cin>>temp)
    {
        prices.push_back(temp);
    }
    int ans=maxProfit(prices);
    cout<<ans<<endl;
    return 0;
}。
旋转数组
题意：

给一个整数数组，要求整体右移k个位置，超出数组的元素按原序填补到前面空出来的位置

解：

1、新数组，先装k到lg-1，然后再装0到k-1

2、bool数组标记处理过的数字，从i开始处理i+k、i+2k直到回到i

3、每移动lg次相当于没移动，所以k=k%lg，最后结果相当于把最后k个数字原序移动到开头，可以先翻转整个数组，然后分别翻转[0,k-1]和[k,lg-1]，原地算法

代码：
#include<bits/stdc++.h>
using namespace std;
inline void reserve(vector<int>& nums,int l,int r)
{
    while(l<r) swap(nums[l++],nums[r--]);
}
void rotate(vector<int>& nums, int k)
{
    int lg=nums.size();k%=lg;
    reserve(nums,0,lg-1);
    reserve(nums,0,k-1);
    reserve(nums,k,lg-1);
}
int main()
{
    vector<int>nums;int temp,k;
    cin>>k;
    while(cin>>temp)
    {
        nums.push_back(temp);
    }
    rotate(nums,k);
    for(auto num:nums) cout<<num<<ends;
    cout<<endl;
    return 0;
}
存在重复元素
题意：

给一个整数数组，如果存在重复的数字返回true

解：

数字范围很大，不能bool数组，可以map或者set这种log级别的查找

先排序再遍历也可以，C++11 std::sort能稳定在O(NlogN)左右

代码：
#include<bits/stdc++.h>
using namespace std;
bool containsDuplicate(vector<int>& nums)
{
    int lg=nums.size();
    sort(nums.begin(),nums.end());
    for(int i=1;i<lg;i++)
    {
        if(nums[i]==nums[i-1]) return true;
    }
    return false;
}
int main()
{
    vector<int> nums;int temp;
    while(cin>>temp)
    {
        nums.push_back(temp);
    }
    bool ans=containsDuplicate(nums);
    cout<<ans<<endl;
    return 0;
}
两个数组的交集 II
题意：

字面意思，求两个数组交集

解：

先排序，然后直接intersection函数求交集，或者双指针处理

T1-免排序

T2-按T3，map方式（数量少，免排序）

T3-内存有限，map或者bool数组（num[i]很小）存个数，然后遍历nums2

代码：

intersection：

vector<int> intersect(vector<int>& nums1, vector<int>& nums2)
{
    vector<int>ans;
    sort(nums1.begin(),nums1.end());
    sort(nums2.begin(),nums2.end());
    set_intersection(nums1.begin(),nums1.end(),nums2.begin(),nums2.end(),inserter(ans,ans.begin()));
    return ans;
}

T3-内存限制：

#include<bits/stdc++.h>
using namespace std;
vector<int> intersect(vector<int>& nums1, vector<int>& nums2)
{
    vector<int>book(1001);
    vector<int>ans;
    for(auto num:nums1) book[num]++;
    for(auto num:nums2)
    {
        if(book[num])
        {
            ans.push_back(num); 
            book[num]--;
        }
    }
    return ans;
}
int main()
{
    vector<int> nums1,nums2;int temp;
    while(cin>>temp)
    {
        nums1.push_back(temp);
    }
    cin.clear();
    while(cin>>temp)
    {
        nums2.push_back(temp);
    }
    
    vector<int> ans=intersect(nums1,nums2);
    for(auto a:ans) cout<<a<<ends;
    cout<<endl;
    return 0;
}
加一
题意：

用vector容器存储了一个非负整数，求计算这个整数+1后的值用vector存储并返回

解：

类似字符串大整数加法，从尾部遍历，一个bool存储进位即可

代码：
#include<bits/stdc++.h>
using namespace std;
vector<int> plusOne(vector<int>& digits)
{
    int lg=digits.size(),add=0;
    
    digits[lg-1]++;
    for(int i=lg-1;i>=0;i--)
    {
        digits[i]+=add;
        add=digits[i]/10;
        digits[i]%=10;
    }
    vector<int>ans;
    if(add) ans.push_back(add); 
    for(auto &digit:digits) ans.push_back(digit);
    return ans;
} 
int main()
{
    vector<int> digits;int temp;
    while(cin>>temp)
    {
        digits.push_back(temp);
    }
    vector<int>ans=plusOne(digits);
    for(auto a:ans) cout<<a<<ends;
    cout<<endl;
    return 0;
}
移动零
题意：

给定一个数组，将零全部移动到后面去，其他元素要保持原序

解：

O(2n)双指针，一个指向最靠前面的0，一个指向最靠前面的非0数字，如果0在非零前面，交换

O(n)由于第N位非0数字应该在第N位，所以index存储目前有几个非0数字，遇到非零数字和对应位置交换（下标偏差）

代码：
#include<bits/stdc++.h>
using namespace std;
void moveZeroes(vector<int>& nums)//N 
{
    int lg=nums.size(),index=-1; 
    for(int i=0;i<lg;i++) if(nums[i]!=0) swap(nums[++index],nums[i]);
    /* //Check
    for(auto num:nums) cout<<num<<ends;
    cout<<endl;*/
}
/*
void moveZeroes(vector<int>& nums)//2N
{
    int l=-1,r=-1,lg=nums.size();
    while(true)
    {
        while(++l<lg && nums[l]!=0);//指向最近的0
        while(++r<lg && nums[r]==0);//指向最近的非0
        if(r==lg || l==lg) break;
        //cout<<l<<" "<<r<<endl;
        if(l<r) swap(nums[l],nums[r]);
        else l--;
    }
     //Check
    for(auto num:nums) cout<<num<<ends;
    cout<<endl;
}*/
int main()
{
    vector<int> nums;int temp;
    while(cin>>temp)
    {
        nums.push_back(temp);
    }
    moveZeroes(nums);
    return 0;
}
两数之和
题意：

给定一个数组nums和整数K，求当i != j时nums[i]+nums[j]==K，返回任意顺序的 i 和 j

解：

map，第一遍遍历存数字A第一次出现的位置，第二遍遍历对于每个A找K-A是否存在（特判A==K-A）

优化：只需要一遍遍历，处理A的时候先不把A加入map，直接查找K-A是否已经存在，就能解决A==K-A的特判

unordered_map：操作快，但不稳定，空间占用大部分情况下大于map

代码：
#include<bits/stdc++.h>
using namespace std;
vector<int> twoSum(vector<int>& nums, int target)
{
    map<int,int>mp;
    int lg=nums.size();
    for(int i=0;i<lg;i++)
    {
        if(mp.count(target-nums[i])) return {mp[target-nums[i]],i};
        else mp[nums[i]]=i;
    } 
    return {0,1};
}
int main()
{
    vector<int> nums;int t,temp;cin>>t;
    while(cin>>temp)
    {
        nums.push_back(temp);
    }
    vector<int>ans=twoSum(nums,t);
    for(auto a:ans) cout<<a<<ends;
    cout<<endl; 
    return 0;
}
有效的数独
题意：

给一个9*9的char数组，表示一个数独，检查每一行，每一列和每个小九宫格里是否有重复的数字

解：

三次遍历，行检查、列检查、小九宫格检查，int使用位运算替换数组进行更快的取值判断和初始化

应该有比官方题解使用更少空间（book进行标记，num可以替换，starts可以换成9段循环或者一大段if条件）

官方题解：使用多个数组存储每行、每列、每个小九宫格里的数字数量，遍历一次，通过位置加入数组

代码：
#include<bits/stdc++.h>
using namespace std;
bool isValidSudoku(vector<vector<char>>& board)
{
    int book,num;
    for(int i=0;i<9;i++)
    {
        book=0;
        for(int j=0;j<9;j++)
        {
            if(board[i][j]=='.') continue;//忽略.
            else
            {
                num=board[i][j]-'0';
                if(book & (1<<num)) return false;
                else book=book|(1<<num); 
            }
        }
    }
    
    for(int i=0;i<9;i++)
    {
        book=0;
        for(int j=0;j<9;j++)
        {
            if(board[j][i]=='.') continue;//忽略.
            else
            {
                num=board[j][i]-'0';
                if(book & (1<<num)) return false;
                else book=book|(1<<num); 
            }
        }
    }
    int starts[9][2]={ {0,0},{3,0},{6,0},{0,3},{3,3},{6,3},{0,6},{3,6},{6,6} }; 
    for(auto start:starts)
    {
        book=0;
        for(int i=start[0];i<start[0]+3;i++)
        {
            for(int j=start[1];j<start[1]+3;j++)
            {
                if(board[i][j]=='.') continue;//忽略.
                else
                {
                    num=board[i][j]-'0';
                    if(book & (1<<num)) return false;
                    else book=book|(1<<num); 
                }
            }
        }
    }
    return true; 
}
int main()
{
    vector<vector<char>> board;int row;cin>>row;
    while(row--)
    {
        vector<char>temp;char ctemp;
        while(cin>>ctemp)
        {
            temp.push_back(ctemp);  
        }
        board.push_back(temp); 
    }
    bool ans=isValidSudoku(board);
    cout<<ans<<endl;
    return 0;
}
旋转图像
题意：

一个N*N数组，顺时针旋转90度，要求原地算法

解：

因为是旋转90度，所以每四个格子相互关联，推一下下标变换就可以了，处理时注意第一行是(0,lg-2)第二行就是(1，lg-3)因为每次旋转完成相当于少一层，行列长度均-2（头尾），同时每行最后一个是由第一个变换来的，再推一下关系

还有一个官方题解两次翻转，上下翻转+对角线翻转，挺妙的，了解一下就行

代码：
#include<bits/stdc++.h>
using namespace std;
void rotate(vector<vector<int>>& matrix)
{
    int lg=matrix.size();
    for(int i=0;i<lg/2;i++)
    {
        for(int j=0;j<lg;j++)
        {
            swap(matrix[i][j],matrix[lg-i-1][j]);
        }
    }
    for(int i=0;i<lg;i++)
    {
        for(int j=i;j<lg;j++)
        {
            swap(matrix[i][j],matrix[j][i]);
        }
    }
    
}
/*
void rotate(vector<vector<int>>& matrix)
{
    int lg=matrix.size();
    for(int i=0;i<lg-1;i++)
    {
        for(int j=i;j<lg-i-1;j++)
        {
            int temp=matrix[i][j];
            swap(temp,matrix[j][lg-i-1]);
            swap(temp,matrix[lg-i-1][lg-j-1]);
            swap(temp,matrix[lg-j-1][i]);
            swap(temp,matrix[i][j]);
        }
    }
}*/
int main()
{
    vector<vector<int>> matrix;int row;cin>>row;
    while(row--)
    {
        vector<int>temp;int itemp;
        while(cin>>itemp)
        {
            temp.push_back(itemp);
        }
        matrix.push_back(temp);
        cin.clear(); 
    }
    rotate(matrix);
    for(auto row:matrix)
    {
        for(int col:row) cout<<col<<ends;
        cout<<endl;
    }
    return 0;
    
}
Qian丶Xi
关注
专栏目录
LeetCode初级算法-数组（手写）
10-09
在本文中，我们将探讨LeetCode平台上初级算法题库中的数组问题。数组作为一种基础数据结构，在编程中被广泛使用，而掌握数组相关的算法问题对于成为一名优秀的软件工程师至关重要。以下是LeetCode中与数组相关的几个...
js代码-初级算法-旋转数组
07-15
在JavaScript编程语言中，"旋转数组"是一种常见的算法问题，主要涉及到数组操作和循环结构。旋转数组的概念是指将一个数组的元素按照指定步长或角度进行旋转，使得原数组的一部分移动到数组的另一端。这个问题在面试...
力扣-初级算法-数组
Hui01080的博客
08-13 944
返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
LeetCode初级算法-数组
CODEING一场空的博客
06-25 491
LeetCode初级算法-数组
力扣初级算法-数组
haotian_guo的博客
07-11 214
菜鸟
LC-初级算法-数组（完结）
wcz1398224452的博客
07-06 1692
可以使用一个临时数组，先把原数组的值存放到一个临时数组中，然后再把临时数组的值重新赋给原数组，重新赋值的时候要保证每个元素都要往后移动k位，如果超过数组的长度就从头开始，所以这里可以使用**（i+k）%length**来计算重新赋值的元素下标。而i统计的是前面"0"的个数，我们可以把"j-i"看做另一个指针，它是指向前面第一个"0"的位置，然后我们让"j"指向的值和"j-i"指向的值交换。当我们把数组中的所有元素都遍历完的时候，集合Set中只会有一个元素，这个就是我们要求的值。dp[i-1][1].....
力扣初级算法 - 数组 - 删除排序数组中的重复项
snwown的博客
02-26 269
题目： 给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。 由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。 将最终结果插入 nums 的前 k 个位置后返回 k 。 不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 作者：力扣 (
初级算法-数组（续）
bellet的博客
07-19 1765
其中box=i/3*3+j/3是在求当前的坐标在第几个九宫格内，可以简单理解i/3三行一划分，j/3三列一划分，但是如果简单相加肯定不对，再接着向下推导（哪怕简单试试也很容易试到），其中也等价于box=i/3+j/3*3;这道题目一般思路创建三个二维数组，分别记录行，列，九宫格的数字，因为数字较少，所以可以采用桶排序判断是否重复出现。怎么比较有没有重复出现呢，很多人应该猜到了，就是与运算，如果结果大于0就是存在，否则不存在。原本以为本题结束了，一看题解，我竟然看到了位运算！位运算总能给人惊喜！...
leedcode-初级算法-数组
文耀的博客
08-08 168
title: leedcode 初级算法 数组 tags: [leedcode,算法,数组] categories: 算法 leedcode date: 2021-06-13 22:10:08 leedcode 初级算法 数组 链接 删除排序数组中的重复项 题目说明 给你一个有序数组nums请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。 题目解析 使用两个索引，i和j i指向基元素.
LeetCode初级算法-数组篇
王星星
10-22 1666
不断成长，不断经历 点击查看题目网址 重复相关 1. 删除排序数组的重复项 这个主要要求原地删除，不使用额外的数组空间，使用O(1)的额外空间 这个题主要可以用双指针法来确定。一个用于遍历数组，记为i；另一个用于记录不重复数组的最后的位置，记为count；其中count和i相互操作用于替换 即： 1   2   2  3  4   count  i 比较的是count-1和 i p...
leetcode学习（初级算法-数组）
lindorx的博客
09-22 314
C语言实现初级数组算法。 1.删除排序数组中的重复项 初级算法 - LeetBook - 力扣（LeetCode）全球极客挚爱的技术成长平台 (leetcode-cn.com)https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2gy9m/实现代码： int removeDuplicates(int* nums, int numsSize){ int *i = nums, *end = nums + nums
Python《剑指offer》算法实现-数组中重复的数字
12-25
1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,多和面试官沟通,然后开始做一些整体的设计和规划。不要急于提交,自己测试几个用例避免错误...
Python《剑指offer》算法实现-数组中的逆序对
12-25
1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,多和面试官沟通,然后开始做一些整体的设计和规划。不要急于提交,自己测试几个用例避免错误...
【算法】双指针
2303_80828380的博客
10-13 770
力扣oj题之双指针算法
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1192
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
【进阶OpenCV】 （14）-- 人脸识别 -- LBPH 算法
m0_74896766的博客
10-15 1070
本篇介绍了如何通过创建LBPH的人脸识别器来进行人脸识别。
力扣10.13
qq_40052678的博客
10-13 435
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
19.面试算法-树的深度优先遍(一)
最新发布
weixin_36401695的博客
10-18 458
面试算法-树的深度优先遍历
PMRF：一种新的图像恢复算法 高质量修复图像 降低图像失真还原跟自然逼真度
GDL_MPY的博客
10-14 1011
（Posterior-Mean Rectified Flow，后验均值修正流）是一种新提出的图像恢复算法，旨在解决图像恢复任务中的。在去噪、超分辨率、修复等不同图像恢复任务中，PMRF能够在多个图像质量评估指标（如PSNR、SSIM、FID等）上表现出色，且没有明显的弱点，展示了其在多任务环境下的稳健性。图像恢复任务（如去噪、超分辨率、盲恢复等）中，常常需要在（如均方误差MSE）和（如图像的真实感和自然度，使用FID、SSIM等衡量）之间做权衡。
LeetCode初级算法解析：数组操作与股票交易
"LeetCode初级算法-数组（手写）" 在LeetCode的初级算法中，数组是一个重要的数据结构，本资源涵盖了10个与数组相关的编程题目，这些题目都是手写的，虽然清晰度可能不够理想，但仍然能提供有效的学习体验。下面，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值