代码随想录算法训练营第四天|24.两两交换链表中的节点，19.删除链表的倒数第N个节点，02.07.链表相交，142.环形链表II

最新推荐文章于 2024-11-12 12:29:51 发布

CZ-0

最新推荐文章于 2024-11-12 12:29:51 发布

阅读量2.6k

点赞数

分类专栏：代码随想录刷题文章标签：链表算法数据结构

本文链接：https://blog.csdn.net/m0_75237738/article/details/127943988

版权

代码随想录刷题专栏收录该内容

52 篇文章 1 订阅

订阅专栏

24.两两交换链表中的节点

力扣题目链接

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

思路

我的方法（和力扣相同，但力扣节省了交换两个指针位置的第二步，在移动指针时直接重新赋值两指针）

cur1 cur2分别指向要交换的两个结点，交换两个结点

交换两个指针的位置

将指针向后移动两位

注意：循环跳出条件

代码随想录

两个临时指针的位置与上述不同

递归(力扣精选的思路)

返回值：交换完成的子链表
调用单元：设需要交换的两个点为 head 和 next，head 连接后面交换完成的子链表，next 连接 head，完成交换
终止条件：head 为空指针或者 next 为空指针，也就是当前无节点或者只有一个节点，无法进行交换

代码

1. 我的方法

class Solution {
public:
    void print(ListNode* dummyHead){
        ListNode *p=dummyHead->next;
        while(p){
            cout<<p->val<<" ";
            p=p->next;
        }
        cout<<endl;
    }
    ListNode* swapPairs(ListNode* head) {
        if(head==NULL) return NULL;
        ListNode *dummyHead=new ListNode(0);
        dummyHead->next=head; //虚拟头结点
        ListNode *cur=dummyHead;
        ListNode *cur1=dummyHead->next;
        ListNode *cur2=cur1->next;
        while(cur1!=NULL&&cur2!=NULL){
            //交换两个结点位置
            cur1->next=cur2->next;
            cur2->next=cur1;
            cur->next=cur2;
            print(dummyHead);
            //复原两个指针指向的位置
            ListNode *temp;
            temp=cur2;
            cur2=cur1;
            cur1=temp;
            //将指针往后移动两位
            if(cur2->next!=NULL){
                cur=cur2;
                cur1=cur2->next;
                cur2=cur2->next->next;
            }
            else{
                break;
            }
            
        }
        return dummyHead->next;
    }
};

2. 力扣

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head==NULL) return NULL;
        ListNode *dummyHead=new ListNode(0);
        dummyHead->next=head; //虚拟头结点
        ListNode *cur=dummyHead;
        while(cur->next!=NULL&&cur->next->next!=NULL){
            ListNode *cur1=cur->next;
            ListNode *cur2=cur->next->next;
            //交换两个结点位置
            cur1->next=cur2->next;
            cur2->next=cur1;
            cur->next=cur2;
            //指针向后移动两位
            cur=cur->next->next;
        }
        return dummyHead->next;
    }
};

复杂度分析

时间复杂度O(n)
空间复杂度O(1)

3. 递归

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head==NULL||head->next==NULL) return head; //交换完成
        ListNode *newHead=head->next;
        ListNode *three=newHead->next;
        newHead->next=head;
        head->next=swapPairs(three);
        return newHead;
    }
};

复杂度分析

时间复杂度O(n)
空间复杂度O(n)

19.删除链表的倒数第N个节点

力扣题目链接

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

进阶：你能尝试使用一趟扫描实现吗？

思路

双指针（我的方法）

fast指针与slow指针相隔n个节点->slow指向待删除结点的前驱结点

计算链表长度

遍历链表，得到链表长度L
再次遍历链表，遍历到第L-n+1个节点时，删除该结点

遍历链表同时将所有节点依次入栈（要将头结点入栈，避免无法获取第一个节点的前驱结点）
弹出栈的第n个节点就是待删除结点，且当前栈顶结点是该结点的前驱结点

代码

双指针

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *dummyHead=new ListNode(0);
        dummyHead->next=head; //虚拟头结点
        ListNode *slow=dummyHead; //倒数第n个结点的前一个结点
        ListNode *fast=dummyHead;
        //控制slow和fast相差n个结点
        while(n--){ 
            fast=fast->next;
        }
        while(fast->next!=NULL){
            slow=slow->next;
            fast=fast->next;
        }
        ListNode *temp=slow->next;
        slow->next=slow->next->next;
        delete temp;
        return dummyHead->next;
    }
};

时间复杂度O(L)，L为链表长度
空间复杂度O(1)

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next=head;
        stack<ListNode*> stk;
        ListNode *cur=dummyHead;//要将头结点入栈，避免无法获取第一个节点的前驱结点
        while(cur){
            stk.push(cur);
            cur=cur->next;
        }
        while(n--){
            stk.pop();
        }
        ListNode *temp=stk.top();
        cur=temp->next;
        temp->next=temp->next->next;
        delete cur;
        return dummyHead->next;
    }
};

时间复杂度O(L)
空间复杂度O(L)

02.07.链表相交

力扣题目链接

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。

思路

我的解法（同代码随想录）

分别遍历两表，计算两表长度
两表长度作差，让长表指针先根据差值移动到短表头结点对齐的位置
同时移动两个指针，比较是否有相同结点

力扣解法（双指针）

当有一个表为空时，说明肯定不相交，返回NULL
当两表都不为空时，pA和pB同时操作

若pA不为空，则将pA移动到下一个结点，若为空，则移动到headB的头结点；

若pB不为空，则将pB移动到下一个结点，若为空，则移动到headA的头结点；

当两个指针指向同一个结点或都为空时，返回它们指向的结点或者空
数学原理

headA和headB的长度分别是m和n，假设headA的不相交部分有a个结点，headB的不相交部分有b个结点，相交部分有c个结点，则有a+c=m，b+c=n

若两链表相交：

如果a==b，则同时到达相交结点，返回相交结点；

如果a!=b，两个指针分别会移动a+c+b、b+c+a次，此时会指向同一个结点

若不相交：

会指向同一个空结点

代码

我的解法

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int sizeA=0; //A链表的长度
        int sizeB=0; //B链表的长度
        ListNode *cur1=headA;
        ListNode *cur2=headB;
        //计算A、B链表的长度
        while(cur1){
            sizeA++;
            cur1=cur1->next;
        }
        while(cur2){
            sizeB++;
            cur2=cur2->next;
        }
        cur1=headA;
        cur2=headB;
        int differ=sizeA-sizeB;
        if(differ>0){
            while(differ--) cur1=cur1->next;
        }
        else{
            while(differ++<0) cur2=cur2->next;
        }
        while(cur1&&cur2){
            if(cur1==cur2) return cur1;
            else{
                cur1=cur1->next;
                cur2=cur2->next;
            }
        }
        return NULL;
    }
};

时间复杂度O(m+n)
空间复杂度O(1)

力扣解法（双指针）

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *pA=headA,*pB=headB;
        if(pA==NULL||pB==NULL) return NULL;
        while(pA!=pB){
            pA=pA==NULL?headB:pA->next;
            pB=pB==NULL?headA:pB->next;
        }
        return pA;
    }
};

时间复杂度O(m+n)
空间复杂度O(1)

142.环形链表II

力扣题目链接

题意：给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

思路

我的解法

使用指针数组存储已遍历的结点，一旦再次遇到了遍历过的节点，就可以判定链表中存在环。

哈希法

使用哈希表存储已遍历的结点

双指针法

判断链表是否有环
如何找到环的入口

1.判断链表是否有环

fast每次走两步，slow每次走一步，必然会在环中相遇

->因为fast移动速度比slow快，相对于slow来说，fast不断靠近slow，所以fast一定可以和slow重合

2.如何找到环的入口

从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。

数学原理（代码随想录中部分解答）

相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点，所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示头结点到环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个（y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z

这就意味着，从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。

解释

为什么 fast指针至少要多走一圈才能相遇slow指针

一圈没走完就相遇->链表没环也能相遇->矛盾
为什么会在slow跑不完一圈就与fast相遇（力扣评论区的优质解答）

一：

假设圈长L

slow进入环的时候，假设fast距离它n步（n<L）

fast一次走两步，slow一次走一步，所以每走一次，它们的距离会缩短1；

那么它们的距离会从n变为n-1,n-2,n-2…1,0;即不可能只超越而不相遇；

这个过程种slow走了n步，而n<L，即slow用不了一圈就会被追上

二：

（极限思想）假设他们都是从入环点开始跑的，那么当慢指针刚好跑完一圈时，快指针刚好跑完两圈，也是在一圈的末尾追上慢指针。而现实情况往往是在慢指针到入环处时快指针已经入环并走了了，所以实际情况一定会在第一圈之内相遇。

代码

我的解法

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *cur=head;
        if(cur==NULL||cur->next==NULL) return NULL;
        ListNode *p[100000];
        int count=0;
        bool flag=true;
        while(cur->next&&flag){
            p[count++]=cur;
            cur=cur->next;
            for(int i=0;i<count;i++){
                if(cur->next==p[i]){
                    flag=false;
                    return p[i];
                }
            }
        }
        return NULL;

    }
};

时间复杂度O(n)
空间复杂度O(n)

哈希法

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode *> visited;
        while(head!=NULL){
            if(visited.count(head))
                return head;
            visited.insert(head);
            head=head->next;
        }
        return NULL;
    }
};

时间复杂度O(n)
空间复杂度O(n)

双指针法

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *slow=head;
        ListNode *fast=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;
                }
                return index1;
            }
        }
        return NULL;
    }
};