力扣做题之旅(菜鸡选手)

编程语言 2023-04-07 02:27:18 阅读次数: 0

2022/12/4

题目(完成)：1.两数之和

我的解答：
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int nums_len=end(nums)-begin(nums);
        int i,j;
        int result_sum;
        int result_numpy[2];
        for(i=0;i<nums_len;i++)
        {
            for(j=0;j<nums_len;j++)
            {
                result_sum=nums[i]+nums[j];
                if(result_sum==target&&i!=j){
                    result_numpy[0]=i;
                    result_numpy[0]=j;
                    return {i,j};
                }
            }
        }
        return {i,j};
    }
};

经验：

1.求数组长度：

int nums_len=end(nums)-begin(nums)

2.嵌套for循环

3.定义数组：

int numpy1[5] = { 0,1,2,3,4 } //注意数组的表达形式{}

2022/12/5

题目(未做出)26：删除有序数组中的重复项

我的解答(二刷):

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int i=1;
        int j=1;
        while(i<nums.size()){
            if(nums[j]!=nums[i-1]){
                i++;
                j++;
            }
            else{
                j++;
                if(nums[i-1]!=nums[j]){
                    nums[i]=nums[j];
                    i++;
                    j=i;
                }
            }
        }
    return i;
    }
};

答案解答(思维有进步，但是还不够)

class Solution {
public:
    //         j
    //     i               
    // 0 1 2 1 2 2 3 4
    int removeDuplicates(vector<int>& nums) {
        int i = 1, j = 1;

        while(j < nums.size())
        {
            if(nums[i - 1] != nums[j])
            {
                nums[i] = nums[j];
                ++i;
            }
            ++j;
        }
        return i;
    }
};

三刷做的答案和第一次做的答案一模一样 真服了

2022/12/6

题目(做出一半)：27.移除元素

我的解答：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int i;
        int j;
        int k;
        for(i=0;i<(nums.size())/2;i++){
            if(nums[i]==val){
                for(j=nums.size()-1;j>=(nums.size())/2;j--){
                    if(nums[j]!=val){
                        k=nums[i];
                        nums[i]=nums[j];
                        nums[j]=k;
                        break;
                    }
                }
            }
        }
    return i;
    }
};

经验：

我的思路是用双指针分别从左右遍历，答案有相同的思路，但是我写的不太好。

第二次解答 依托答辩

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int i,j=1;
        int a=0;
        while(j<nums.size()){
            if(nums[i-1]!=val){
                i++;
                j++;
            }
            else{
                j++;
                if(nums[j]!=val){
                    a=nums[i-1];
                    nums[i-1]=nums[j];
                    nums[j]=a;
                    i++;
                    j=i;
                }
            }

        }
    return i;

    }
};

非常简单直接的解题思路

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

2022/12/7

题目(未做出)：35.搜索插入位置

题目中若要求算法的时间复杂度是O(logn)，那么这个算法基本上就是二分法。

我的解答：超时 第二次

我的解答
class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int i=0;
        int a;
        while(i<nums.size()){
            if(nums[i]<=target&&target<=nums[i+1]){
                if(nums[i]==target){
                    a=i;
                }
                else if(nums[i+1]==target){
                    a=i+1;
                }
                else{
                    a=i+1;
                }

            }
            else{
                i++;
            }
        }
    return a;
    } 
};
答案
class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size()-1;
        int mid = 0;
        while(left <= right){
            mid = left + (right - left)/2;
            if(nums[mid] == target){
                return mid;
            }
            if(nums[mid] >target){
                right = mid-1;
            }
            else{
                left = mid+1;
            }
        }
        return left;
    }
};

2022/12/8

题目(基本完成)：66.加一

我的解答
class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int length=digits.size()-1;
        digits[length]++;
        int i=digits.size()-1;
        while(i>0){
            if(digits[i]==10){
                digits[i]=0;
                digits[i-1]++;
            }
            i--;
        }
        if(digits[0]==10){
            vector<int>ans(digits.size()+1);
            ans[0]=1;
            return ans;
        }
        return digits;
    }
};

经验：

可以自己定义一个新的数组并返回；定义一个全为0的数组：

vector<int>ans(digits.size()+1);

二刷 和第一遍做的一模一样 服了 一点进步没有啊

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int i = digits.size() - 1;
        digits[i]++;
        while(i>=0){
            if(digits[i]==10){
                digits[i]=0;
                digits[i-1]++;
            }
            i--;
        }
    return digits;
    }
};

2022/12/9

题目(超时)：88.合并两个有序数组

我的解答
class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int i;
        int j=0;
        for(i=m;i<m+n;i++){
            nums1[i]=nums2[j];
            j++;
        }
        int k=m+n;
        int i_1;
        int j_1;
        int test;
        int times=0;
        while(k>2){
            for(i_1=0;i_1<k;i_1++){
                for(j_1=0;j_1<k;j_1++){
                    if(nums1[i_1]>=nums1[j_1]){
                        times++;
                    }
                    if(times==k){
                        test=nums1[i_1];
                        nums1[i_1]=nums1[k-1];
                        nums1[k-1]=test;
                        k--;
                        // i_1=0;
                        // j_1=0;
                    }
                }
            }
        }
    } 
};
答案
class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int r=nums1.size();
        while(n>0){
            if(m>0&&nums1[m-1]>nums2[n-1]){
                nums1[r-1]=nums1[m-1];
                m--;
                r--;
            }
            else{
                nums1[r-1]=nums2[n-1];
                n--;
                r--;
            }
        }
    } 
};

经验：

1.感觉自己写的逻辑上应该没问题，但是超时了。

2.因为两个数组都是非递减顺序的，所以从后往前比较两个数组的值大小然后插入。

二刷 未作出 还不如第一次 好歹还有点思路

2022/12/10

题目(未做出)：118.杨辉三角

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

经验：

1.nums.resize()

2.nums[i][j]

2023/2/15

题目(我感觉没问题，但是答案也没有类似的解答)：136.只出现一次的数字

我的解答
class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int i,j;
        int times=0;
        int a=0;
        for(i=0;i<nums.size();i++){
            for(j=0;j<nums.size();j++){
                if(nums[i]==nums[j]){
                    times++;
                }
            }
            if(times==1){
                return nums[i];   
            }
        }
    return 0;
    }
};

异或运算有两种特性：

  • x ^ x = 0，任意相同数字 x 异或的结果为 0；
  • x ^ 0 = x，任意非零数字与 0 异或的结果为其本身。
  • 异或运算满足交换律和结合律。

2023/3/27

题目(未做出)121：买卖股票的最佳时机

参考答案
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int cost=INT_MAX,profit=0;
        for(int price : prices){
            cost=min(cost,price);
            profit=max(profit,price-cost);
        }
    return profit;
    }
};

2023/3/29

题目(完成)169：多数元素

sort(nums.begin(),nums.end());

 题目(完成)217：存在重复元素

参考答案
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        for (int i = 1; i < nums.size(); i++) 
            if (nums[i-1] == nums[i]) return true;
        return false;
    }
};

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> set;
        for (int num: nums) {
            if (set.find(num) != set.end()) return true;
            set.insert(num);        
        }
        return false;
    }
};

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        if(nums.size() <= 1) return false;
        unordered_map<int,int> map;
        for(int num : nums) {
            map[num]++;
            if(map[num] >= 2) return true;
        }
        return false;
    }
};

unordered_set  find(key):查找以值为 key 的元素，如果找到，则返回一个指向该元素的正向迭代器；反之，则返回一个指向容器中最后一个元素之后位置的迭代器

2023/3/30

题目(未完成)219:存在重复元素2

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_map<int,int> map;
        for(int i=0;i<nums.size();i++){
            if(!map.empty() && map.count(nums[i])>0){
                if(i-map[nums[i]]<=k){
                    return true;
                }
            }
            map[nums[i]]=i;
        }   
        return false;
    }
};

map和set两种容器的底层结构都是红黑树，所以容器中不会出现相同的元素，因此count()的结果只能为0和1，可以以此来判断键值元素是否存在(当然也可以使用find()方法判断键值是否存在)。

2023/4/2

题目(思路正确，做出来一半)228：汇总区间

我的解答
class Solution {
public:
    vector<string> summaryRanges(vector<int>& nums) {
        vector<string>ans;
        int i=1;
        int j=1;
        string s;
        while(j<nums.size()){
            if(nums[j]-nums[i-1]>1){
                s = to_string(nums[i-1]);
                ans.push_back(s);
                i++;
                j++;
            }
            else{
                if(j==nums.size()-1){
                    s=to_string(nums[i-1]) + "->" + to_string(nums[j]);
                    ans.push_back(s);
                }
                int times = 1;
                j++;
                if(nums[j]-nums[i]==times){
                    j++;
                    times++;
                }
                if(nums[j]-nums[i]>times){
                    // map[k]="nums[i-1],nums[j-1]]";
                    // s += to_string(nums[l]) + "->" + to_string(nums[r - 1]);
                    s=to_string(nums[i-1]) + "->" + to_string(nums[j-1]);
                    ans.push_back(s);
                    if(j==nums.size()-1){
                        s=to_string(nums[j]);
                        ans.push_back(s);
                    }
                    i=j+1;
                    j=i;
                }
            }
        }
        return ans;

    }
};

// s = to_string(nums[l]);
//                 ans.push_back(s);

答案
class Solution {
public:
    vector<string> summaryRanges(vector<int>& nums) {
        int n = nums.size();
        vector<string> ans;
        if(n == 0) {
            return {};
        }//nums是个空数组
        int l = 0;
        while(l < n) {
            string s;
            int r = l + 1;
            if(r == n) {           //mums数组中只有一个元素
                s = to_string(nums[l]);
                ans.push_back(s);
                break;
            }
            while(r < n && nums[r] == nums[r - 1] + 1) {
                ++r;
            }
            if(r == l + 1) {
                s = to_string(nums[l]);
            } 
            if(r > l + 1) {
                s += to_string(nums[l]) + "->" + to_string(nums[r - 1]);
            }
            l = r;
            ans.push_back(s);
        }
        return ans;
    }
};

push_back()函数将一个新元素加到vector的最后，位置为当前最后一个元素的下一个元素

2023/4/3

题目(完成)268：消失的数字

我的解答

我的解答
class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int n = nums.size();
        sort(nums.begin(),nums.end());
        int r = 0;
        if(nums[0]!=0){
            return r;
        }
        if(n == r + 1){
            return r+1;
        }
        while((r+1<n) && nums[r+1] == nums[r] + 1){
            r++;
        }
        return r+1;
    }
};

2023/4/4

题目(完成)283：移动零

暴力解法
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int times=0;
        int j = 0;
        // if(nums.size()==0){
        //     return nums
        // }
        for(int i=0;i<nums.size();i++){
            if(nums[i]!=0){
                nums[j]=nums[i];
                j++;
                times++;
            }
        }
        for(times;times<nums.size();times++){
            nums[times]=0;
        }
        // return nums;


    }
};
双指针
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int left = 1;
        int right = 1;
        while(right<nums.size()){
            if(nums[left - 1]== 0){
                if(nums[right]!=0){
                    nums[left-1]=nums[right];
                    nums[right]=0;
                    left++;
                    right=left;
                }
                else{
                    right++;
                }
            }
            else{
                left++;
                right++;
            }
        }


    }
};

答案
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int leftIndex = 0;
        int rightIndex = 0;

        /**
         * 还是两个指针，如果nums[rightIndex]不等于0的时候才交换，并且对left进行加
        */
        while(rightIndex < nums.size()){
            if(nums[rightIndex]){
                int t = nums[rightIndex];
                //很简洁 双指针自己和自己换的思想需要好好理解一下
                nums[rightIndex] = nums[leftIndex];
                nums[leftIndex] = t;
                ++leftIndex;
            }
            ++rightIndex;
        }
    }
};

2023/4/5

题目(完成一半)303：区域和检索-数组不可变

对题目和函数的理解没到位

class NumArray {
    vector<int>test;//全局变量
public:
    NumArray(vector<int>& nums) {
        test.resize(nums.size()+1);
        for(int i=0;i<nums.size();i++){
            test[i+1]=test[i]+nums[i];
        }

    }
    int sumRange(int left, int right) {
        return test[right+1]-test[left];
    }
};

2023/4/6

题目(未完成)349：两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        /* 存放结果，之所以用set是为了给结果集去重 */
        unordered_set<int> result;
        /* 由于输出的元素唯一不重复因此可以将nums1转化为unordered_set哈希表 */
        unordered_set<int> nums1_set(nums1.begin(),nums1.end());
        for(int i = 0; i < nums2.size(); i++){
            /* 判断nums1_set中是否有nums2的元素，若有将此值插入到result */
            if(nums1_set.find(nums2[i]) != nums1_set.end())
                result.insert(nums2[i]);
        }
        return vector<int> (result.begin(),result.end());
    }
};

猜你喜欢

转载自blog.csdn.net/qq_42784882/article/details/128169819
今日推荐
AI小程序有哪些？AI小程序哪个好用？微信小程序AI写作叫什么？免费的ai小程序推荐 ai写作小程序推荐
灵办AI工具(科研学术,代码编程,学习辅导,图书报告)功能介绍
Linux内核源码分析（非常详细）零基础入门到精通，收藏这一篇就够了
【C++篇】启航——初识C++（上篇）
数据飞轮崛起：数据中台真的过时了吗？
828华为云征文——使用Flexus云服务器X实例CentOS镜像下创建MySQL服务器教程
阿里巴巴出品的6款AI神器，你用过几个？
【机器学习】多模态AI——融合多种数据源的智能系统
HashiCorp 创始人向 Zig 软件基金会捐赠 30 万美元
1-8 月我国软件业务收入 85492 亿元，同比增长 11.2%
零基础入门鸿蒙开发 HarmonyOS NEXT星河版开发学习
豆包MarsCode帮我2小时完成Go语言系统从开发、测试到部署全流程最佳实践，云IDE迁移PHP企业级项目最佳实践
周排行
Ubuntu+apache2+php5+mysql+phpmyadmin的php环境搭建
基于YOLOv3+Kalman-Filter实现Multi-target tracking
解释C++实例化类的指针类型中的new
苹果手机页面不兼容问题——mui
Python基础语法
javascript学习笔记一【预解释】
python内置函数 map
【Git】使用webstorm操作git
this与super关键字（一）
python list 使用技巧
每日归档
更多
2024-10-04(63)
2024-10-03(2)
2024-10-02(60)
2024-10-01(0)
2024-09-30(0)
2024-09-29(0)
2024-09-28(4)
2024-09-27(60)
2024-09-26(0)
2024-09-25(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022