Leetcode究极刷题笔记（21~25）

最新推荐文章于 2024-05-31 17:17:25 发布

抱着太阳吃雪糕z

最新推荐文章于 2024-05-31 17:17:25 发布

阅读量583

点赞数 1

文章标签： leetcode 链表数据结构

本文链接：https://blog.csdn.net/weixin_64394633/article/details/129759691

版权

（21）合并两个有序链表（简单）

实现思路：

本题的实现类似于归并排序，我们先创建一个新链表的头结点与尾结点，然后同时遍历list1与list2，分别将二者之中较小的那一个插入新的链表即可，最后我们将剩余的节点直接接在新链表的尾部输出就可以了

代码实现如下：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        auto newnode=new ListNode(-1),tail=newnode;
        while(list1 && list2)
        {
            if(list1->val<list2->val)
            {
                tail->next=list1;
                tail=tail->next;
                list1=list1->next;
            }
            else
            {
                tail->next=list2;
                tail=tail->next;
                list2=list2->next;
            }
        }
        if(list1) tail->next=list1;
        if(list2) tail->next=list2;
        return  newnode->next;
    }
};

（22）括号生成（中等）

实现思路：
合法的括号序列：
（1）任意前缀中‘（’的数量大于等于‘）’的数量（2）左右括号数量相同
排列的条件：
a.左括号的数量小于n b.右括号的数量小于n并且此时左括号的数量大于右括号的数量
代码实现如下：

class Solution {
public:
    vector<string> res;
    void dfs(int n,int lc,int rc,string ans)
    {
        if(lc==n && rc==n) res.push_back(ans);
        else
        {
            if(lc<n) dfs(n,lc+1,rc,ans+'(');
            if(rc<n && lc>rc) dfs(n,lc,rc+1,ans+')');
        }
        
    }
    vector<string> generateParenthesis(int n) {
        dfs(n,0,0,"");
        return res;
    }
};

（23）合并k个升序链表（困难）

实现思路：首先在实现之前先了解一下仿函数，仿函数其实就是一个类，重载了一个运算符operator（），它的类对象可以像函数一样使用。

本题实现的思路与我们之前写过合并里那个有序链表的思路是大致相同的，首先我们将比较下来的每一个链表的最小值放在新链表的头节点，如果此时放进去的头结点有下一个节点的话，就将对应的下一个节点放入优先级队列进行排列，由此来实现我们对应的代码。

代码实现如下：

class Solution {
public:
    struct compare
    {
        bool operator()(ListNode* a,ListNode* b)
        {
            return a->val>b->val;
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*,vector<ListNode*>,compare> heap;
        auto dummy=new ListNode(-1),tail=dummy;
        for(auto l:lists)
        {
            if(l) heap.push(l);
        } 
        while(heap.size())
        {
            auto t=heap.top();
            heap.pop();
            tail=tail->next=t;
            if(t->next) heap.push(t->next);
        }
        return dummy->next;
    }
};

（24）两两交换链表中的节点（中等）

实现思路：
本题虽然是中等题，但是只要画出图来理解就十分好写，这里不做过多赘述，直接看代码。

代码实现如下：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        auto dummy=new ListNode(-1);
        dummy->next=head;
        for(auto p=dummy;p->next && p->next->next;)
        {
            auto a=p->next,b=a->next;
            p->next=b;
            a->next=b->next;
            b->next=a;
            p=a;
        }
        return dummy->next;
    }
};

（25）k个一组翻转链表（困难）

实现思路：
首先我们第一步就是要确定来表是否有k个节点，这是第一步判断；接着我们逐步对k个节点进行翻转，同时在开始与结束时记住对应的头节点与尾结点，翻转之后将对应的关系串联起来，这样就实现了我们的代码

代码实现如下：

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        auto dummy=new ListNode(-1);
        dummy->next=head;
        for(auto p=dummy;;)
        {
            auto q=p;
            for(int i=0;i<k&&q;i++)
            {
                q=q->next;
            }
            if(!q) break;
            auto a=p->next,b=a->next;
            for(int i=0;i<k-1;i++)
            {
                auto c=b->next;
                b->next=a;
                a=b,b=c;
            }
            auto c=p->next;
            p->next=a,c->next=b;
            p=c;
        }
        return dummy->next;
    }
};