Task04——采用C++

最新推荐文章于 2024-10-01 05:07:35 发布

偷闰土的猹

最新推荐文章于 2024-10-01 05:07:35 发布

阅读量86

点赞数 1

分类专栏： DataWhale—LeetCode腾讯精选50题EverydayTa 文章标签： c++ 算法 leetcode 数据结构

本文链接：https://blog.csdn.net/qq_34811382/article/details/112626456

版权

DataWhale—LeetCode腾讯精选50题EverydayTa 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本文介绍了LeetCode中的三道经典问题：016.最接近的三数之和、020.有效的括号和021.合并两个有序链表的解决方案。分别使用了暴力算法、双指针法和递归方法。对于三数之和，首先尝试暴力求解，然后优化为双指针降低复杂度。有效括号问题通过栈来判断括号匹配性。合并两个有序链表则通过递归方式实现。这些方法展示了算法设计和优化的重要性。

摘要由CSDN通过智能技术生成

016. 最接近的三数之和

LeetCode链接：https://leetcode-cn.com/problems/3sum-closest/
在这里插入图片描述
思路:

暴力算法：直接三个数求和存入一个数组中，再让数组每一个元素与target相减，找到最小的数，最后返回最小的数加上target就是所求。时间复杂度是O(N^3)，会TLE。

上代码：C++

class Solution
{
public:
    int threeSumClosest(vector<int> &nums, int target)
    {
        vector<int> ThreeSum;
        for (int i = 0; i < nums.size()-2; i++)
        {
            for (int j = i + 1; j < nums.size()-1; j++)
            {
                for (int k = j + 1; k < nums.size(); k++)
                {
                    ThreeSum.push_back(nums[i] + nums[j] + nums[k]-target);
                }
            }
        }
        int min=INT_MAX;
        for(int i=0;i<ThreeSum.size();i++){
            if(abs(min)>abs(ThreeSum[i]))
                min=ThreeSum[i];
        }
        return min+target;
    }
};

双指针法，先排序，再定义left和right指针，外层使用for循环定义i是第一位数组，left=i+1，right=最后一位。利用while循环，找到最小的。时间复杂度为O(N^2)。

上代码:C++

class Solution
{
public:
    int threeSumClosest(vector<int> &nums, int target)
    {
        sort(nums.begin(), nums.end());
        int result = nums[0] + nums[1] + nums[2];
        int min = INT_MAX;
        for (int i = 0; i < nums.size() - 2; i++)
        {
            int left = i + 1;
            int right = nums.size() - 1;
            while (left < right)
            {
                int ThreeSum = nums[i] + nums[left] + nums[right];
                if (abs(ThreeSum - target) < abs(result - target))
                    result = ThreeSum;
                if (ThreeSum - target == 0)
                    return target;
                else if (ThreeSum < target)
                    left++;
                else
                    right--;
            }
        }
        return result;
    }
};

020.有效的括号

LeetCode链接:https://leetcode-cn.com/problems/valid-parentheses/
在这里插入图片描述
思路：

利用栈，栈先入后出，正好利用这个，如果出现’(’、’[’、’{’，则在栈压入’)’、’]’、’}’。当出现反括号即’)’、’]’、’}'后，将栈顶元素与字符串中的括号比较，不同则返回假。最后查看栈中是否为空，为空则返回真，否则，返回假。我是通过switch实现的。
上代码：C++

class Solution
{
public:
    bool isValid(string s)
    {
        stack<char> temp;
        for (char &ch : s)
        {
            switch (ch)
            {
            case '(':
                temp.push(')');
                break;
            case '[':
                temp.push(']');
                break;
            case '{':
                temp.push('}');
                break;
            case ')':
                if (temp.empty() || temp.top() != ch)
                    return false;
                else
                    temp.pop();
                break;
            case ']':
                if (temp.empty() || temp.top() != ch)
                    return false;
                else
                    temp.pop();
                break;
            case '}':
                if (temp.empty() || temp.top() != ch)
                    return false;
                else
                    temp.pop();
                break;
            default:;
            }
        }
        return temp.empty();
    }
};

021.合并两个有序链表

LeetCode链接：https://leetcode-cn.com/problems/merge-two-sorted-lists/

在这里插入图片描述
思路：

利用递归,直接看代码吧，代码简单。l1==nullptr或者l2=nullptr是递归出口。

上代码：C++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution
{
public:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
    {
        if (l1 == nullptr)
            return l2;
        if (l2 == nullptr)
            return l1;
        if (l1->val <= l2->val)
        {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        }
        if (l1->val > l2->val)
        {
            l2->next = mergeTwoLists(l2->next, l1);
            return l2;
        }
    return nullptr;
    }
};