C++vector类相关OJ练习

C++忠实粉丝

于 2024-09-06 23:23:31 发布

阅读量1.1k

点赞数 12

分类专栏： C++语法学习文章标签： c++ 开发语言算法

本文链接：https://blog.csdn.net/wer24_25/article/details/141968287

版权

C++语法学习专栏收录该内容

19 篇文章 0 订阅

订阅专栏

个人主页：C++忠实粉丝
欢迎点赞👍 收藏✨ 留言✉ 加关注💓本文由 C++忠实粉丝原创

C++vector类相关OJ练习

收录于专栏【C++语法基础】
本专栏旨在分享学习C++的一点学习笔记，欢迎大家在评论区交流讨论💌

1. 杨辉三角

OJ链接:118. 杨辉三角 - 力扣（LeetCode）

题目描述:

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

示例 1:

输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

示例 2:

输入: numRows = 1
输出: [[1]]

提示:

1 <= numRows <= 30

解题思路:

1. 用resize自定义创建杨辉三角空间

2. 根据杨辉三角的变化发现规律:

<1>. 每一行的第一个和最后一个都为1(为了方便可以都初始化为1)

<2>. 每一行中间的数vv[i][j]等于前面一行的vv[i-1][j] + vv[i-1][j - 1];

代码展示:

class Solution {
public:
    vector<vector<int>> generate(int numRows) 
    {
        vector<vector<int>> vv(numRows);
        for(int i = 0; i < numRows; i++)
        {
            vv[i].resize(i+1, 1);
        }
        for(int i = 2; i < numRows; i++)
        {
            for(int j = 1; j < i; j++)
            {
                vv[i][j] = vv[i-1][j] + vv[i-1][j-1];            
            }
        }
        return vv;
    }
};

2. 只出现一次的数

OJ链接:136. 只出现一次的数字 - 力扣（LeetCode）

题目描述:

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

你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

示例 1 ：

输入：nums = [2,2,1]
输出：1

示例 2 ：

输入：nums = [4,1,2,1,2]
输出：4

示例 3 ：

输入：nums = [1]
输出：1

提示：

1 <= nums.length <= 3 * 104
-3 * 104 <= nums[i] <= 3 * 104
除了某个元素只出现一次以外，其余每个元素均出现两次。

解题思路:

使用0来分别异或数组中的所有数

1. 相同的数异或等于0

2. 0与任何数异或等于该数本身

最后得到的数即为只出现一次的数!

代码展示:

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int val = 0;
        for(auto e : nums)
        {
            val ^= e;
        }
        return val;
    }
};

3. 只出现一次的数ii

OJ链接:137. 只出现一次的数字 II - 力扣（LeetCode）

题目描述:

给你一个整数数组 nums ，除某个元素仅出现一次外，其余每个元素都恰出现 三次。请你找出并返回那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法且使用常数级空间来解决此问题。

示例 1：

输入：nums = [2,2,3,2]
输出：3

示例 2：

输入：nums = [0,1,0,1,0,1,99]
输出：99

提示：

1 <= nums.length <= 3 * 104
-231 <= nums[i] <= 231 - 1
nums 中，除某个元素仅出现一次外，其余每个元素都恰出现三次

解题思路:

该题有多种解题思路，比如：

1. 统计每个数字出现的次数，然后找出只出现1次的数字，缺点：需要借助辅助空间

2. 对数据进行排序，然后找出只出现1次的数字，缺点：时间复杂度不是O(N)

而题目要求了，时间复杂度必须为O(N)线性时间复杂度，因此便增加了题目的难度。

题目说：只有一个数字出现一次，其余数字均出现3次，假设数组为{3,5,3,3}

通过分析可知：

3的二进制：0 0 0 0 0 0 1 1

5的二进制：0 0 0 0 0 1 0 1

3的二进制：0 0 0 0 0 0 1 1

3的二进制：0 0 0 0 0 0 1 1

0 0 0 0 0 1 3 4 二进制1的总数

对于出现3次的数字，各位出现的次数都是3的倍数，因此对统计的为1的比特总数%3

0 0 0 0 0 1 0 1 = 5

结果就是只出现一次的数字

代码展示:

// 时间复杂度：O(32*N)--->O(N)  空间复杂度：O(1)
class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ans = 0;
        for (int i = 0; i < 32; ++i) {


            // 统计该每个数字第i个比特位为1的总数
            int total = 0;
            for (int num: nums) {
                total += ((num >> i) & 1);
            }


            // 如果total能够被3整除，说明只出现一次的数字在该位置上一定是0
            // 否则在该位置上一定是1
            if (total % 3) {
                ans |= (1 << i);
            }
        }
        return ans;
    }
};

4. 只出现一次的数iii

OJ链接:260. 只出现一次的数字 III - 力扣（LeetCode）

题目描述:

给你一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。找出只出现一次的那两个元素。你可以按 任意顺序 返回答案。

你必须设计并实现线性时间复杂度的算法且仅使用常量额外空间来解决此问题。

示例 1：

输入：nums = [1,2,1,3,2,5]
输出：[3,5]
解释：[5, 3] 也是有效的答案。

示例 2：

输入：nums = [-1,0]
输出：[-1,0]

示例 3：

输入：nums = [0,1]
输出：[1,0]

解题思路:

排序法思路：

1. 从前往后遍历，若出现两次，则为相同元素，索引加2

2. 若出现一次（前后不等），则为所需要的数，存入vector，索引加1

3. 若没到尾后位置，说明最后一个元素为出现一次的数

代码展示:

class Solution 

{
public:
  vector<int> singleNumber(vector<int>& nums) 
  {
    sort(nums.begin(), nums.end());
    vector<int> res;
    int i = 0;

    for ( ; i < nums.size() - 1; ) 
    {
      if (nums[i] == nums[i + 1]) 
      {
        i += 2;
      } 
      else 
      {
        res.push_back(nums[i]);
        i += 1;
      }
    }
    if (i < nums.size()) 
    {
      res.push_back(nums[i]);
    }
    return res;     
  }

};

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

OJ链接:26. 删除有序数组中的重复项 - 力扣（LeetCode）

题目描述:

给你一个 非严格递增排列 的数组 nums ，请你原地删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持一致。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被通过。

解题思路:

使用erase删除重复数据，不过会导致数据挪动，时间复杂度为O(N*N)

思路：

1. 由于数据是排序好的，通过查询每一个数据的重复区间

2. 将重复区间进行删除，只保留一个数据即可

代码展示:

class Solution {
public:
  int removeDuplicates(vector<int>& nums) 
  {
    if(nums.size() == 1)
      return 1;
    vector<int>::iterator it = nums.begin();
    vector<int>::iterator it1 = it;
    it1++;

    while(it != nums.end())
    {
      while(it1!=nums.end() && *it1==*it)
        it1++;
      it = nums.erase(++it, it1);
      it1 = it;
      it1++;
    }
    return nums.size();
  }
};