算法刷题:LC初级算法(一)

前言

今天本来要写模板编程的,但是,网上对模板编程的争论不休,我一时也拿不定主意。
这些都是次要的,最主要的是,我拿不定主意,就会瞎学。
并不是说有学无害,跟你说这些的人是害你的。
学,就要时间成本,我们是没有别的东西要学了吗?算法很好的话当初也不至于连笔试都不敢参加。

不说废话了,从头刷起。


删除排序数组中的重复项

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

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

作者:力扣 (LeetCode)
链接:https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2gy9m/
来源:力扣(LeetCode) 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

示例:

输入:nums = [1,1,2]
输出:2, nums = [1,2]
解释:函数应该返回新的长度 2 ,并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

思路都在注释中了,在原数组上维护一个二次数组,将第一次出现的数往前提:

int removeDuplicates(vector<int>& nums) {
      int sz = nums.size();
      if(sz == 0)	//首先,不排除数组长度为0的情况
        return 0;
        
      int sz2 = 1;	//sz2纪录留下来的元素数
      int flag = nums[0];	//由于是有序列表,flag用来纪录当前所处位置的数值
      for(int i = 1;i<sz;i++){
          if(nums[i] != flag){	//如果前后数值不同,那就进来吧
            if(i > sz2)	//i>sz2,说明中间有了重复项
                nums[sz2] = nums[i];	//那就把i处提到前面去
            sz2++;	//sz2继续往后走
            flag = nums[i];	//切换一个flag了
          }
      }  
      return sz2;
    }

买卖股票的最佳时机 II

给定一个数组 prices ,其中 prices[i] 是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。

注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

示例 1:

输入: prices = [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天(股票价格 = 1)的时候买入,在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     随后,在第 4 天(股票价格 = 3)的时候买入,在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6-3 = 3

示例 2:

输入: prices = [1,2,3,4,5]
输出: 4
解释: 在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     注意你不能在第 1 天和第 2 天接连购买股票,之后再将它们卖出。因为这样属于同时参与了多笔交易,你必须在再次购买前出售掉之前的股票。

示例 3:

输入: prices = [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0

作者:力扣 (LeetCode)
链接:https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2zsx1/
来源:力扣(LeetCode) 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。


思路其实也很简单,就是不断的寻找波峰和波谷。
那波峰和波谷又要怎么找,因为我根本不知道什么时候波峰,什么时候波谷,先波峰还是先波谷,中间迭代多少次也不知道。
没事的,波峰波谷在这么转,都在波里面,那就有办法。


代码实现(思路都在注释里了):

int maxProfit(vector<int>& prices) {
        int i = 1;
        int sz = prices.size();
        int buy = prices[0];
        int sell = buy;
        int price = 0;

        while(i<sz){
            //当股票一路上涨
            while(i<sz && prices[i]>=prices[i-1]){
                sell = prices[i];
                i++;
            }
            //涨停板
            price+=(sell-buy);
            //当股票开始一路下跌
            while(i<sz && prices[i]<=prices[i-1]){
                buy = prices[i];
                i++;
            }
            //跌完就该回去了
        }
        return price;
    }

旋转数组

给定一个数组,将数组中的元素向右移动 k 个位置,其中 k 是非负数。

进阶:

尽可能想出更多的解决方案,至少有三种不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗?

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1: [7,1,2,3,4,5,6]
向右旋转 2: [6,7,1,2,3,4,5]
向右旋转 3: [5,6,7,1,2,3,4]

示例 2:

输入:nums = [-1,-100,3,99], k = 2
输出:[3,99,-1,-100]
解释: 
向右旋转 1: [99,-1,-100,3]
向右旋转 2: [3,99,-1,-100]

作者:力扣 (LeetCode)
链接:https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2skh7/
来源:力扣(LeetCode) 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。


思路:这个还要多说吗?左右手翻转定理嘛。
现在跟我伸出左手右手,背面向下,左右手平移互换位置。这就是我们的旋转嘛。

别急。
我们现在将左手翻转,再将右手翻转。
接着,将两只手作为整体翻转(有一只手会比较别扭,调整一下),认真看看,跟前面是不是一样的。


所以,代码实现:

 void rotate(vector<int>& nums, int k) {
    int sz = nums.size();
    if(k<sz)
        sz -= k
    else
        sz-=(k%sz);
            
    reverse(nums.begin(),nums.begin()+sz);
    reverse(nums.begin()+sz,nums.end());
    reverse(nums.begin(),nums.end());
}

存在重复元素

给定一个整数数组,判断是否存在重复元素。

如果存在一值在数组中出现至少两次,函数返回 true 。如果数组中每个元素都不相同,则返回 false 。

示例 1:

输入: [1,2,3,1]
输出: true

示例 2:

输入: [1,2,3,4]
输出: false

作者:力扣 (LeetCode)
链接:https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x248f5/
来源:力扣(LeetCode) 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。


思路:思路其实很明确,但是我想试一下哈希表。

bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> us;
        for(int x:nums){
            if(us.find(x)!=us.end())
                return true;
            us.insert(x);
        }
        return false;
    }

只出现一次的数字

给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现两次。找出那个只出现了一次的元素。

说明:

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗?

思路:这题不想浪费时间,位运算,不了解位运算的小伙伴建议整体的去了解一下,很重要的。

int singleNumber(vector<int>& nums) {
        int x = nums[0];
        for(int i = 1;i<nums.size();i++)
            x = x^nums[i];
        return x;

    }

不再赘言。


两个数组的交集 II

给定两个数组,编写一个函数来计算它们的交集。

示例 1:

输入:nums1 = [1,2,2,1], nums2 = [2,2]
输出:[2,2]

示例 2:

输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出:[4,9]

说明:

输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。
我们可以不考虑输出结果的顺序。

进阶:

如果给定的数组已经排好序呢?你将如何优化你的算法?
如果 nums1 的大小比 nums2 小很多,哪种方法更优?
如果 nums2 的元素存储在磁盘上,内存是有限的,并且你不能一次加载所有的元素到内存中,你该怎么办?

作者:力扣 (LeetCode)
链接:https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2y0c2/
来源:力扣(LeetCode) 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。


思路:思路很多,比方说先排个序啥的。
但是,我不用,我就要用哈希表,诶,就是练。

vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int> um;
        int sz1 = nums1.size();
        int sz2 = nums2.size();

        vector<int> temp;

        if(sz1>sz2){
            for(int x:nums1)    //将大的插入哈希表
                um[x]+=1;

            for(int y:nums2){
                if(um[y]>0){    //如果找到了
                    temp.push_back(y);
                    um[y]--;
                }
            }
        }
        else{
           for(int x:nums2)    //将大的插入哈希表
                um[x]+=1;

            for(int y:nums1){
                if(um[y]>0){    //如果找到了
                    temp.push_back(y);
                    um[y]--;
                }
            } 
        }
        return temp;
    }

加一

给定一个由 整数 组成的 非空 数组所表示的非负整数,在该数的基础上加一。

最高位数字存放在数组的首位, 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外,这个整数不会以零开头。

示例 1:

输入:digits = [1,2,3]
输出:[1,2,4]
解释:输入数组表示数字 123

作者:力扣 (LeetCode)
链接:https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2cv1c/
来源:力扣(LeetCode) 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

这个题啊,其实正常情况暴力求解,但是不排除那种一串9的。
其实对于一串就可以当做特例来解决,但是我没那兴趣。

我就想先将数组翻转过来,头部加个1,在转回去,诶,就是玩儿、

vector<int> plusOne(vector<int>& digits) {
        reverse(digits.begin(),digits.end());
        int i = 0;
        while(i<digits.size()){
            if(digits[i]!=9){
                digits[i]+=1;
                reverse(digits.begin(),digits.end());
                return digits;
            }
            else
                digits[i] = 0;
            i++;
        }
        digits.push_back(1);
        reverse(digits.begin(),digits.end());
        return digits;
    }

移动零

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

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

说明:

必须在原数组上操作,不能拷贝额外的数组。
尽量减少操作次数。

那这不就是快慢指针吗?

void moveZeroes(vector<int>& nums) {

        int fast = 0;
        int slow = 0;

        int sz = nums.size();

        while (slow < sz) {
            while (slow < sz && nums[slow] != 0)
                slow++;

            if (fast <= slow)
                fast = slow + 1;

            for (; fast < sz; fast++) {
                if (nums[fast] != 0) {
                    int temp = nums[slow];
                    nums[slow] = nums[fast];
                    nums[fast] = temp;
                    break;
                }
            }
            slow++;
        }
    }

一篇八题。本篇结束。


已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 代码科技 设计师:Amelia_0503 返回首页
实付 29.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值