labuladong刷题笔记一（单链表）

烫青菜

已于 2022-05-07 21:18:15 修改

阅读量1.3k

点赞数 1

文章标签： C++ labuladong

于 2022-04-20 18:15:38 首次发布

本文链接：https://blog.csdn.net/weixin_39766005/article/details/124303790

版权

刷题专栏收录该内容

5 篇文章 1 订阅

订阅专栏

一、单链表

1.单链表的六大解题套路，你都见过么？（快慢指针）

（1）21. 合并两个有序链表

（2）23. 合并K个升序链表

（3）19. 删除链表的倒数第 N 个结点

4.如何高效判断回文单链表？（快慢指针+左右指针）

（1）234. 回文链表

一、单链表

1.单链表的六大解题套路，你都见过么？（快慢指针）

p->next=p1：表示节点p的下一个节点是p1

p=p->next：表示向前移动，修改指针p的位置，把p指向原来的下一个节点。

（1）21. 合并两个有序链表

（2）23. 合并K个升序链表

优先队列

（3）19. 删除 链表的倒数第 N 个 结 点

快慢指针

（4）876. 链表的中间结点

快慢指针

（5）141. 环形链表

快慢指针

（6）160. 相交链表

注意这段代码：p1永远都不会是nullptr

if(p1->next)
{
    p1=p1->next;
}
else{
    p1=headB;
}

（7）83. 删除排序链表中的重复元素

注意最后slowNode->next=nullptr;

返回head即可。

2.递归反转链表：如何拆解复杂问题

（1）206. 反转链表(递归)

    ListNode* reverseList(ListNode* head) {
        if(head==nullptr)
        {
            return nullptr;
        }
        if(head->next==nullptr)
        {
            return head;
        }
        ListNode* node=reverseList(head->next);
        head->next->next=head;
        head->next=nullptr;
        return node;
    }

（2）92. 反转一部分链表（递归）

    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) {}
    };

    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if(left==1)
        {
            return reverseN(head,right);
        }
        head->next=reverseBetween(head->next,left-1,right-1);
        return head;
    }
    //反转前n个结点
    ListNode* successor=nullptr;
    ListNode* reverseN(ListNode* head,int n)
    {
        if(head==nullptr)
        {
            return nullptr;
        }
        if(n==1||head->next==nullptr)
        {
            successor=head->next;
            return head;
        }
        ListNode* last=reverseN(head->next,n-1);
        head->next->next=head;
        head->next=successor;
        return last;
    }

3.递归思维：k 个一组反转链表

（1）25. K 个一组翻转链表（迭代）

class Solution {
public:
    int i=0;

    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode *a = head , *b = head ;
        ListNode *myNode=new ListNode(-1);
        ListNode *p=myNode;
        if(!head||!head->next)
        {
            return head;
        }

        while(i < k && b)
        {
            b=b->next;
            ++i;
            if(i==k)
            {
                myNode->next = reverse(a,b);
                for(int j=0;j<k;j++)
                {
                    cout<<myNode->next->val<<endl;
                    myNode=myNode->next;
                }
                a=b;
                i=0;
            }
            else if(b==nullptr)
            {
                myNode->next=a;
            }
        }
        return p->next;

    }

    //反转a与b之间的结点[a,b]
    ListNode* reverse(ListNode* a,ListNode* b)
    {
        ListNode *currentNode=a,
                *lastNode=nullptr,
                *nextNode=nullptr;
        while(currentNode!=b)
        {
            nextNode=currentNode->next;
            currentNode->next=lastNode;
            lastNode=currentNode;
            currentNode=nextNode;
        }
        cout<<"lastnode:"<<lastNode->val<<endl;
        return lastNode;
    }
};