2019年12月5日，决心开始刷题了，开篇博客记录下，希望自己后面有所提升。
数组
删除排序数组中的重复项
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if (nums.size() <= 1)
{
return nums.size();
}
else
{
int i = 0;
while (i < nums.size())
{
while (i + 2 <= nums.size() && nums[i] == nums[i + 1])
{
nums.erase(std::begin(nums) + i);
}
i++;
}
return i;
}
}
};
买卖股票的最佳时机 II
class Solution {
public:
int maxProfit(vector<int>& prices) {
if (prices.size() <= 1)
{
return 0;
}
else if (prices.size() == 2)
{
if (prices.back() > prices.front())
{
return prices.back() - prices.front();
}
else
{
return 0;
}
}
else
{
bool sealready = false;
int income = 0;
int up_price = 0;
int low_price = INT_MAX;
//int low_price_ready = 0;
for (int i = 0; i < prices.size(); i++)
{
if (!sealready)
{
if (prices[i] > low_price)
{
sealready = true;
while (sealready)
{
if (prices[i] >= up_price)
{
up_price = prices[i];
if (i == prices.size() - 1)
{
income += up_price - low_price;
break;
}
}
else
{
income += up_price - low_price;
sealready = false;
up_price = 0;
low_price = prices[i];
i--;
break;
}
i++;
}
}
else
{
low_price = prices[i];
}
}
}
return income;
}
}
};
旋转数组
这道题我用了两种方法，第一种是用循环一个一个的移动数组，但是太慢了，成绩垫底就不放出了，后面我就优化了一遍
class Solution {
public:
void rotate(vector<int>& nums, int k) {
for (int i = 1; i <= k_real; i++)
{
nums.insert(nums.begin(), nums.back());
nums.pop_back();
}
}
};
class Solution {
public:
void rotate(vector<int>& nums, int k) {
//首先取模，用来判断知否移动多圈
int k_real = k % nums.size();
//用这种方式来先做插入，然后再删除，vector的这种插入和删除的思想是挺好的
nums.insert(nums.begin(), nums.end() - k_real, nums.end());
nums.erase(nums.end() - k_real, nums.end());
}
};
存在重复元素
/思路如下：先使用sort函数将vector排序，依次对比前后的值，这样时间复杂度是O(t)
class Solution {
public:
bool containsDuplicate(vector<int>& nums) {
if (nums.size() <= 1)
{
return false;
}
std::sort(nums.begin(), nums.end());
for (std::vector<int>::iterator it = nums.begin();
it != nums.end() - 1;
it++)
{
if (*it == *(it + 1))
{
return true;
}
}
return false;
}
};
只出现一次的数字
//思路：
//先排序，同时根据题意数组肯定是奇数个，然后从前两个数开始成对的判断，如果相同，就判断成对的数
//的第二个数与再下一个数是否相同，相同返回成对数的第一个，不同返回成对数的第二个
class Solution {
public:
int singleNumber(vector<int>& nums) {
std::sort(nums.begin(), nums.end());
if (nums.size() == 1)
{
return nums.front();
}
for (int i = 0; i < nums.size() - 2; i = i + 2)
{
if (nums[i] != nums[i + 1])
{
if (nums[i + 1] == nums[i + 2])
{
return nums[i];
}
else
{
return nums[i + 1];
}
}
}
return nums.back();
}
};
两个数组的交集 II
class Solution {
public:
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
if (nums1.size() == 0 || nums2.size() == 0)
{
return std::vector<int>{};
}
std::sort(nums1.begin(), nums1.end());
std::sort(nums2.begin(), nums2.end());
int length_min = std::min(nums1.size(), nums2.size());
std::vector<int> nums{};
bool ii = nums1.empty();
while (!nums1.empty() && !nums2.empty())
{
if (nums1.back() == nums2.back())
{
nums.push_back(nums1.back());
nums1.pop_back();
nums2.pop_back();
}
else if (nums1.back() > nums2.back())
{
nums1.pop_back();
}
else
{
nums2.pop_back();
}
}
return nums;
}
};
加一
很简单
class Solution {
public:
vector<int> plusOne(vector<int>& digits) {
int i = digits.size() - 1;
while (digits[i] == 9 && i >= 0)
{
digits[i] = 0;
i--;
if (i < 0)
{
std::vector<int> one_vector{ 1 };
one_vector.insert(one_vector.end(), digits.begin(), digits.end());
return one_vector;
}
}
digits[i]++;
return digits;
}
};
移动0
class Solution {
public:
void moveZeroes(vector<int>& nums) {
int zero_counter = 0;
for (std::vector<int>::iterator it = nums.begin();
it != nums.end();
it++)
{
while (*it == 0)
{
it = nums.erase(it);
zero_counter++;
if (it == nums.end())
{
break;
}
}
if (it == nums.end())
{
break;
}
}
if (zero_counter > 0)
{
nums.insert(nums.end(), zero_counter, 0);
}
}
};
两数之和
使用的暴力法
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
for (int i = 0; i < nums.size() - 1; i++)
{
for (int j = i + 1; j < nums.size(); j++)
{
if (nums[i] + nums[j] == target)
{
std::vector<int> nums_out{ i, j };
return nums_out;
}
}
}
return nums;
}
};
有效的数独
class Solution {
public:
bool isValidSudoku(vector<vector<char>>& board) {
for (int i = 0; i < board.size(); i++)
{
std::vector<char> ini_char_vector1{ '1', '2', '3', '4', '5', '6', '7', '8', '9',
'.', '.', '.', '.', '.', '.', '.', '.', '.', };
std::vector<char> ini_char_vector2{ '1', '2', '3', '4', '5', '6', '7', '8', '9',
'.', '.', '.', '.', '.', '.', '.', '.', '.', };
for (int j = 0; j < board[i].size(); j++)
{
//首先按照每行去查找，当查找到一个数值时，就从临时的数组中剔除有的数
bool flg_find_same = false;
bool flg_is_same = true;
for (std::vector<char>::iterator it = ini_char_vector1.begin();
it != ini_char_vector1.end();
it++)
{
if (board[i][j] == *it)
{
flg_find_same = true;
flg_is_same = false;
it = ini_char_vector1.erase(it);
if (it == ini_char_vector1.end())
{
break;
}
}
if (flg_find_same)
{
break;
}
}
if (flg_is_same)
{
return false;
}
//然后按照列去查找
flg_find_same = false;
flg_is_same = true;
for (std::vector<char>::iterator it = ini_char_vector2.begin();
it != ini_char_vector2.end();
it++)
{
if (board[j][i] == *it)
{
flg_find_same = true;
flg_is_same = false;
it = ini_char_vector2.erase(it);
if (it == ini_char_vector2.end())
{
break;
}
}
if (flg_find_same)
{
break;
}
}
if (flg_is_same)
{
return false;
}
}
}
//由于按照格子查找和按照行列查找不同
//所以放在这里单独处理
for (int i = 0; i < 9; i += 3)
{
for (int j = 0; j < 9; j += 3)
{
std::vector<char> ini_char_vector1{ '1', '2', '3', '4', '5', '6', '7', '8', '9',
'.', '.', '.', '.', '.', '.', '.', '.', '.', };
for (int k = 0; k < 3; k++)
{
for (int t = 0; t < 3; t++)
{
bool flg_find_same = false;
bool flg_is_same = true;
for (std::vector<char>::iterator it = ini_char_vector1.begin();
it != ini_char_vector1.end();
it++)
{
if (board[i + k][j + t] == *it)
{
flg_find_same = true;
flg_is_same = false;
it = ini_char_vector1.erase(it);
if (it == ini_char_vector1.end())
{
break;
}
if (flg_find_same)
{
break;
}
}
}
if (flg_is_same)
{
return false;
}
}
}
}
}
return true;
}
};
旋转图像
class Solution {
public:
void rotate(vector<vector<int>>& matrix) {
int i_max = matrix.size() / 2 - 1;
int size = matrix.size() - 1;
for (int i = 0; i <= i_max; i++)
{
for (int j = i; j < matrix.size() - i - 1; j++)
{
int t = matrix[j][size - i];
matrix[j][size - i] = matrix[i][j];
matrix[i][j] = matrix[size - j][i];
matrix[size - j][i] = matrix[size - i][size - j];
matrix[size - i][size - j] = t;
}
}
}
};
字符
反转字符串
class Solution {
public:
void reverseString(vector<char>& s) {
for (int i = 0; i < s.size() / 2; i++)
{
char str = s[i];
s[i] = s[s.size() - 1 - i];
s[s.size() - 1 - i] = str;
}
}
};
整数反转
这一次超越了100% 的人
class Solution {
public:
int reverse(int x) {
std::string res;
std::stringstream ss;
ss << x;
ss >> res;
bool is_negative = false;
if (res.front() == '-')
{
//res.erase(res.begin());
is_negative = true;
}
while (res.back() == '0')
{
res.pop_back();
}
if (!is_negative)
{
for (int i = 0; i < res.size() / 2; i++)
{
char str = res[i];
res[i] = res[res.size() - 1 - i];
res[res.size() - 1 - i] = str;
}
}
else
{
for (int i = 1; i < (res.size() + 1) / 2; i++)
{
char str = res[i];
res[i] = res[res.size() - i];
res[res.size() - i] = str;
}
}
//判断字符串反转后是否溢出
ss.clear();
long num = 0;
ss << res;
ss >> num;
if (num > INT32_MAX || num < INT32_MIN)
{
return 0;
}
ss.clear();
ss << res;
ss >> x;
return x;
}
};
1305
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
