Leetcode刷题心得

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;
    }
};
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 代码科技 设计师:Amelia_0503 返回首页