算法学习随笔 3_链表有关算法题

P_in_k

已于 2022-04-24 15:29:25 修改

阅读量507

点赞数

分类专栏：算法学习随笔文章标签：算法学习数据结构

于 2022-03-20 13:01:58 首次发布

本文链接：https://blog.csdn.net/p_in_k/article/details/123609668

版权

算法学习随笔专栏收录该内容

8 篇文章 1 订阅

订阅专栏

本章记录一些链表的较为经典或者自己第一次做印象比较深刻的算法以及题型，包含自己作为初学者第一次碰到题目时想到的思路以及网上其他更优秀的思路，本章持续更新中......

No 707. 设计链表(中等)

No 206.反转链表(简单)

No 24. 两两交换链表中的节点 (中等)

No 19.删除链表的倒数第N个节点（中等）

No 142.环形链表II（中等）

No 707. 设计链表(中等)

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/design-linked-list/

题目描述：

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

思路：这个题目是对链表基本操作的练习，没有太大难度，注意中间量的使用和指针的变化顺序即可，结合代码和注释应该很容易理解。注意index的值从0开始。

class MyLinkedList {
public:
    //定义单链表结构体
    struct ListNode{
        int val;
        ListNode *next;
        ListNode(int val):val(val),next(nullptr){}
    };

    MyLinkedList() {
        //初始化单链表
        virtualHeadNode = new ListNode(0);
        size = 0;
    }
    
    //获取第index结点的val值,index从0开始 
    int get(int index) {
        if(index>(size-1)||index<0){
            return -1;
        }
        ListNode *temp=virtualHeadNode->next;
        while(index--){
            temp=temp->next;
        }
        return temp->val;
    }
    
    //将val这个值加入到链表头
    void addAtHead(int val) {
        ListNode *insert=new ListNode(val);
        insert->next=virtualHeadNode->next;
        virtualHeadNode->next=insert;
        size++;
    }
    //将val这个值加入到链表尾
    void addAtTail(int val) {
        ListNode *temp=virtualHeadNode;
        ListNode *insert=new ListNode(val);
        while(temp->next!=NULL){
            temp=temp->next;
        }
        temp->next=insert;
        size++;
    }
    // 在指定位置添加节点
    void addAtIndex(int index, int val) {
        if(index>size){
            return;
        }
        ListNode *temp=virtualHeadNode;
        ListNode *insert=new ListNode(val);
        //结点从0开始
        while(index--){
            temp=temp->next;
        }
        insert->next=temp->next;
        temp->next=insert;
        size++;
    }
    //删除指定位置的结点，结点从0开始
    void deleteAtIndex(int index) {
        if(index<0||index>(size-1)){
            return;
        }
        ListNode *temp=virtualHeadNode;
        while(index--){
            temp=temp->next;
        }
        ListNode *del=temp->next;
        temp->next=temp->next->next;
        delete del;
        size--;
    }
    //打印
    void printLinkedList(){
        ListNode *temp=virtualHeadNode;
        while(temp->next!=NULL){
            cout<<temp->next->val;
            temp=temp->next;
        }
        cout<<endl;
    }
//类内部使用
private:
    int size;
    ListNode *virtualHeadNode;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

No 206.反转链表(简单)

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-linked-list/

题目描述：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：
输入：head = [1,2]
输出：[2,1]

示例 2：

示例 3：
输入：head = []
输出：[]

涉及技巧：双指针或者递归

双指针是一种比较常用的技巧。利用一个快指针和一个慢指针来共同操作数组，运用得当可以很好的优化算法。也可以使用递归实现，利用递归本质上还是实现交换操作。

思路：双指针：定义一个per指针和一个now指针，每次都将now指针的next设置为per，然后将per移动到now的位置，再将now移动到下一个位置。因为是先操作了now->next，所以在操作之前要先保存now->next，否则将会丢失now->next。递归方法：思路是一样的，只是利用递归实现了将per移动到now和now移动到下一个位置的操作。

/**
 * 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 *reverse(ListNode *pre,ListNode *now){
        if(now==NULL) {
            return pre;
        }
        ListNode *temp;
        temp=now->next;
        now->next=pre;
        return reverse(now,temp);
    }
    ListNode* reverseList(ListNode* head) {
        //递归调用
        return reverse(NULL,head);

        // //普通
        // ListNode *now=head;
        // ListNode *pre=nullptr;
        // ListNode *temp;
        // while(now!=NULL){
        //     temp=now->next;//保存now的下一个结点，因为马上要改变now的next，如果不保存会导致丢失
        //     now->next=pre;
        //     pre=now;
        //     now=temp;//将now移动到之前保存好的next节点上
        // }
        // return pre;
    }
};

No 24. 两两交换链表中的节点 (中等)

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/swap-nodes-in-pairs/

题目描述：

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：
输入：head = []
输出：[]

示例 3：
输入：head = [1]
输出：[1]

涉及技巧：直接模拟

思路：两两交换一共需要三步，如图所示。首先设置一个虚拟头结点，便于处理head。这题的关键就是要理清楚指针的变化，只有清楚的知道指针的变化才能明白需要几个temp，分别保存那些节点。步骤一中我们将cur->next的节点改变了，所以我们需要将cur->next的节点，也就是节点1保存到临时节点中。在步骤二中我们将节点2的next节点改变了，所以我们需要将节点2的next节点保存到临时节点中。在步骤三中，节点1的next节点又节点2变为了节点3，是最后一步操作，所以我们不需要保存节点2。

注意：在变化过程中，当cur->next发生变化时，此时的链表已经不再是最初的链表了，也就是说此时的cur->next已经不是最初的cur->next了，同时所有长度大于cur->next的操作也都会发生变化，比如cur->next->next也不再是最初的cur->next->next了。

/**
 * 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* swapPairs(ListNode* head) {
        ListNode *virtualHeadNode=new ListNode(0,head);
        ListNode *now=virtualHeadNode;
        ListNode *temp1;
        ListNode *temp2;
        while(now->next!=NULL&&now->next->next!=nullptr){
            // 哪个节点需要保存临时变量？：箭头指向哪个节点就保存哪个节点
            temp1=now->next;
            temp2=now->next->next->next;

            now->next=now->next->next;
            now->next->next=temp1;//此时now->next为节点2
            //若这里用temp代替now->next，则此时的now->next为节点1
            now->next->next->next=temp2;//此时now->next->next为节点1

            now=now->next->next;
        }
        return virtualHeadNode->next;
    }
};

No 19.删除链表的倒数第N个节点（中等）

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/

题目描述：

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：
输入：head = [1], n = 1
输出：[]

示例 3：
输入：head = [1,2], n = 1
输出：[1]

涉及技巧：双指针。

思路：本题的关键在于如何找到倒数第n个节点并往前推一个节点。这里可以利用双指针，首先让快指针先走n+1步，当快指针移动到末尾，变为NULL的时候，此时慢指针的next就是要删除的节点，而快指针先走n+1步的目的就是让慢指针到达要删除的节点的前一个。找到这个节点后的删除操作就很简单了。

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        //总体思路：利用快慢指针构造差值n+1，这样当快指针到末尾时，慢指针的next就是要删除的倒数第n个节点
        ListNode *virtualHeadNode =new ListNode(0,head);
        //双指针
        ListNode *slow=virtualHeadNode;
        ListNode *fast;
        n=n+1;//为了让slow指到要删除元素的上一个，slow->next是要删除的节点
        while(n--){
            slow=slow->next;
            fast=slow;
        }
        // 得到fast以后重置slow指针
        slow=virtualHeadNode;
        //当fast指向空节点时，slow指向要删除的节点的前一个，slow->next为要删除的节点
        while(fast!=NULL){
            slow=slow->next;
            fast=fast->next;
        }
        //删除节点
        ListNode *del=slow->next;
        slow->next=slow->next->next;
        delete del;
        return virtualHeadNode->next;
    }
};

No 142.环形链表II（中等）

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/linked-list-cycle-ii/

题目描述：

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改链表。

示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

涉及技巧：双指针，且涉及到一定的数学知识。

思路：首先要分为两大部分，判断是否有环和判断环的起点。

判断是否有环：定义两个指针，让快指针每一次移动两步，慢指针每一次移动一步。这样的话如果存在环，那么快慢指针一定会相遇。因为快指针每次走两步，慢指针每次走一步，相当于快指针总是在以一步一步的接近慢指针，不会出现跳过慢指针的情况，因此如果有环，那么快慢指针一定会相遇。

判断环的起点：这个部分涉及到一点数学推理。我们首先可以将两个指针的移动情况用上图表示。当快慢指针相遇时，慢指针走过的距离是 x+y，快指针走过的距离是 x+y+n(y+z)。因为快慢指针相遇一定是在环内相遇的，而且此时快指针一定已经至少绕完了环的一圈，也就是n≥1。又因为快指针每次走两步，慢指针每次走一步，所以快指针走过的距离为慢指针走过的距离的2倍。所以可以化简得到 x=n(y+z)-y，这个x就是头结点到环的入口的距离。当n等于1的时候，这个式子变成 x=z，也就是说此时如果让一个指针从头结点出发，另一个指针从相遇位置出发，当这两个指针相遇时，此时的位置就是环的入口。那么n大于1的时候呢，情况和n=1时的情况也是一样的，只不过是从快慢指针相遇位置出发的那个指针多走了n圈罢了，最终两个指针相遇的位置仍然是环的起点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //1.判断是否有环    2.判断环的起点
        ListNode *fast=head;
        ListNode *slow=head;
        while(fast!=NULL&&fast->next!=NULL){
            // 快指针走两步，慢指针走一步，如果有环的话，相当于快指针相对于慢指针一步一步的接近，最终必然会重合
            fast=fast->next->next;
            slow=slow->next;
            //快慢指针重合，此时快指针必然已经起码绕完了一整圈环
            if(fast==slow){
                //从头结点和重合地点各自单步移动一个指针，重合时就是环的起点
                ListNode *index1=fast;
                ListNode *index2=head;
                while(index1!=index2){
                    index1=index1->next;
                    index2=index2->next;
                }
                // slow=x + y   fast=x + y + n (y + z)   n>=1
                // x为起点到环的起点的距离；y为环的起点到快慢指针相遇位置的距离；z为相遇位置到环起点的距离
                return index1;
            }
        }
        return NULL;
    }
};