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

---

前言

链表题公式：链表转数组→操作数组→数组转链表
打卡第四天（周末补上的），今天继续学习链表，链表专题也快结束了，
除了环形链表的双指针法仍有点迷糊，其他的都还是不错的

---

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

LeetCode 24. 两两交换链表中的节点
文章讲解
视频讲解
状态 : AC

公式解，直接看代码就行了

• AC代码示例:

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *p=head;
        vector<int> v;
        //链表->数组
        while(p){
            v.push_back(p->val);
            p=p->next;
        }
        //操作数组
        int n=v.size();
        if(n<2) return head;
        for(int i=0;i<n-1;i+=2){
            swap(v[i],v[i+1]);
        }
        //数组->链表
        head->val=v[0];
        p=head;
        for(int i=1;i<n;i++){
            ListNode* Next=new ListNode(v[i]);
            p->next=Next;
            p=p->next;
        }
        return head;
    }
};

• 时间复杂度:O(n)
• 空间复杂度：O(n)

---

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

LeetCode 19. 删除链表的倒数第 N 个结点
文章讲解
视频讲解
状态 : AC

这个题也直接公式，主要数组转链表的时候判断条件要注意

• AC代码示例:

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int index) {
        ListNode *p=head;
        vector<int> v;
        //链表->数组
        while(p){
            v.push_back(p->val);
            p=p->next;
        }
        //操作数组
        v[v.size()-index]=-10;
        //数组->链表
        if(v.size()==1)return nullptr;
        int i=0;
        while(v[i]<0){
            i++;
        }
        p=head;
        head->val=v[i];
        head->next=nullptr;
        for(++i;i<v.size();i++){
            if(v[i]>=0){
                ListNode* Next=new ListNode(v[i]);
                p->next=Next;
                p=p->next;
            }
        }
        return head;
    }
};

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

---

LeetCode 面试题 02.07. 链表相交

LeetCode 面试题 02.07. 链表相交
文章讲解
视频讲解 ：无
状态 : AC

这个题！就不好用公式了，试了好久没写出来，然后看讲解
卡哥一个图就让我悟了。。

直接把末端对齐，然后比较结点就行了

• AC代码示例:

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int asizea=0;int bsizeb=0;
        ListNode* pa=headA;ListNode* pb=headB;
        while(pa){
            pa=pa->next;
            asizea++;
        } 
        while(pb){
            pb=pb->next;
            bsizeb++;
        }
        pa=headA,pb=headB;
        while(asizea!=bsizeb){
            if(asizea>bsizeb){
                pa=pa->next;
                asizea--;
            }else if(bsizeb>asizea){
                pb=pb->next;
                bsizeb--;
            }
        }
        while(pa && pb){
            if(pa==pb) return pa;
            pa=pa->next;
            pb=pb->next;
        }

        return pa;
    }
};

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

---

LeetCode 142. 环形链表 II

LeetCode 142. 环形链表 II
文章讲解
视频讲解
状态 : 哈希AC，双指针的还在学习

哈希表

哈希真的啥都能做，要注意set的查询，是返回迭代器的，如果没有查到就返回容器的end（）；

• AC代码示例:（哈希表）

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        set<ListNode*> harh;
        ListNode *p=head;
        while(p){
            harh.insert(p);
            auto j=harh.find(p->next);
            if(j!=harh.end())return p->next;
            p=p->next;
        }
        return p;
    }
};

• 时间复杂度：O(nlogn) 应该是?set查询元素复杂度为logn
• 空间复杂度：O(n)

双指针

• 还没学会，明天补上 OvO

---

总结

环形链表部分明天再看看
学校要期中考试了，可能会很忙，但算法学习也不能落下
加油加油
2024-4-21