【C++】leetcode刷题

那可真是太开心了呢

已于 2022-02-07 11:19:03 修改

阅读量181

点赞数

分类专栏： c++ 文章标签： leetcode 算法散列表

于 2022-01-12 10:07:04 首次发布

本文链接：https://blog.csdn.net/qq_44708426/article/details/122413905

版权

c++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

第1题两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int i,j;
        for(i = 0;i<nums.size()-1;i++)
        {
           for(j = i+1;j<nums.size();j++)
           {
               if(nums[i] + nums[j] == target)
               {
                   return {i,j};
               }
           }
        }
        return {i,j};
    }
};

第9题回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。

示例 1：

输入：x = 121
输出：true
示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：

输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。
示例 4：

输入：x = -101
输出：false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处

class Solution {
public:
    bool isPalindrome(int x) {
        vector<int> array;
        if(x < 0)
            return false;
        else
        {
            while(x)
            {
                array.push_back(x%10);
                x = x/10;
            }
            for(int i = 0,j=array.size()-1;i<array.size()/2;i++,j--)
            {
                if(array[i]!=array[j])
                    return false;
            }
        }
        return true;
    }
};

//力扣题解
class Solution {
public:
    bool isPalindrome(int x) {
        // 特殊情况：
        // 如上所述，当 x < 0 时，x 不是回文数。
        // 同样地，如果数字的最后一位是 0，为了使该数字为回文，
        // 则其第一位数字也应该是 0
        // 只有 0 满足这一属性
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }

        int revertedNumber = 0;
        while (x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }

        // 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
        // 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
        // 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
        return x == revertedNumber || x == revertedNumber / 10;
    }
};

第14题最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"
示例 2：

输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。

提示：

1 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组成

//横向查找

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if (!strs.size()) {
            return "";
        }
        else
        {
            string s = strs[0];
            for(int i = 1;i<strs.size();i++)
            {
                s = longestCommonPrefix(s,strs[i]);
                if(s == "")
                {
                    return "";
                }
            }
            return s;
        }
    }

    //找两个字符串的公共前缀
    string longestCommonPrefix(const string& str1, const string& str2) {
        int length = min(str1.size(), str2.size());
        int index = 0;
        while (index < length && str1[index] == str2[index]) {
            ++index;
        }
        return str1.substr(0, index);
    }
};

第20题有效括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true
示例 2：

输入：s = "()[]{}"
输出：true
示例 3：

输入：s = "(]"
输出：false
示例 4：

输入：s = "([)]"
输出：false
示例 5：

输入：s = "{[]}"
输出：true

//执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
//内存消耗：6 MB, 在所有 C++ 提交中击败了98.06%的用户
//代码丑是丑点，但是是我执行效率最高的代码了

class Solution {
public:
    bool isValid(string s) {
        vector<char> array;

        for(int i = 0;i < s.size();i++)
        {
            auto iter = array.rbegin();
            if(iter == array.rend())
            {
                if(s[i] == ')' || s[i] == ']' || s[i] == '}')
                    return false;
                else array.push_back(s[i]);
            }
            else if(*iter == '(' && s[i] == ')')
            {
                array.pop_back();
            }
            else if(*iter == '[' && s[i] == ']')
            {
                array.pop_back();
            }
            else if(*iter == '{' && s[i] == '}')
            {
                array.pop_back();
            }
            else array.push_back(s[i]);
        }
        if(array.size() > 0)
            return false;
        else return true;
    }
};

第26题删除有序数组的重复项

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

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

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

示例 1：

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

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

//这是我自己的常规做法，时间复杂度和空间复杂度都挺高


class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int count = 0;
        for(auto iter = nums.begin();iter != nums.end();++iter)
        {
            if(iter != nums.begin() && *iter == *(iter - 1))
            {
                nums.erase(iter);   //将重复的数据删掉
                iter--;             //删除数据之后指向前一个
            }
            else count++;
        }
       return count;
    }
};

//双指针解法，快慢指针，快指针遍历整个数组，慢指针指向不重复部分数组

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.size() <= 1) 
            return nums.size();
        
        int fast_point = 1, slow_point = 1;
        for(int fast_point = 1;fast_point < nums.size(); fast_point++)
        {
            if(nums[fast_point] != nums[fast_point - 1])
                nums[slow_point++] = nums[fast_point];
        }
        return slow_point;
    }
};

第27题移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        if(nums.size() == 0) 
            return 0;
        
        int slow_point = 0;
        for(int fast_point = 0; fast_point < nums.size(); fast_point++)
        {
            if(nums[fast_point] != val)
                nums[slow_point++] = nums[fast_point];
        }
        return slow_point;
    }
};

第566题：重塑矩阵

在 MATLAB 中，有一个非常有用的函数 reshape ，它可以将一个 m x n 矩阵重塑为另一个大小不同（r x c）的新矩阵，但保留其原始数据。

给你一个由二维数组 mat 表示的 m x n 矩阵，以及两个正整数 r 和 c ，分别表示想要的重构的矩阵的行数和列数。

重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。

如果具有给定参数的 reshape 操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

示例 1：

输入：mat = [[1,2],[3,4]], r = 1, c = 4
输出：[[1,2,3,4]]
示例 2：

输入：mat = [[1,2],[3,4]], r = 2, c = 4
输出：[[1,2],[3,4]]

//这个题总感觉好像没考啥，由于对C++不是很熟练在二维数组初始化那里卡了一下，其他都是暴力解决的

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
        if(mat[0].size() == 0 || mat[0].size() * mat.size() != r*c)
            return mat;
        
        vector<vector<int>> v(r, vector<int>(c, 0));
        int k = 0;
        int n = 0;
        for(int i = 0;i<mat.size();i++)
        {
            for(int j = 0;j<mat[0].size();j++)
            {
                if(k < c)
                {
                    v[n][k] = mat[i][j];
                    k++;
                }
                
                if(k >= c)
                {
                    n++;
                    k = 0;
                }

            }
        }
        return v;
    }
};

//官方是用了除号和取余

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {
        int m = nums.size();
        int n = nums[0].size();
        if (m * n != r * c) {
            return nums;
        }

        vector<vector<int>> ans(r, vector<int>(c));
        for (int x = 0; x < m * n; ++x) {
            ans[x / c][x % c] = nums[x / n][x % n];
        }
        return ans;
    }
};

那可真是太开心了呢

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【C++】leetcode刷题

给定一个整数数组 nums和一个整数目标值 target，请你在该数组中找出和为目标值 target的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。示例 1：输入：nums = [2,7,11,15], target = 9输出：[0,1]解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。示例 2：输入：nums = [3,2,4], ta...
复制链接

扫一扫