算法打卡day4|链表篇02|Leetcode 9 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交、142.环形链表II

本文链接：https://blog.csdn.net/unstoppableyi/article/details/136299571

算法题

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

题目链接:24. 两两交换链表中的节点

大佬视频讲解：两两交换链表中的节点视频讲解

个人思路

不画图感觉有点乱，画图理解一下。如下图，所以可以根据双指针或者递归解这道题，主要是把握好替换节点时的顺序，像火车一样，头1到尾1，尾1到头2...

解法

虚拟头节点

按照如上图顺序完成两数翻转

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyNode=new ListNode(-1,head);
        dummyNode.next=head;//虚拟头节点初始化

        ListNode cur=dummyNode;
        ListNode temp;
        ListNode firstNode;//交换节点1
        ListNode secondNode;//交换换节点2
        while(cur.next!=null &&cur.next.next!=null){//节点1,2不能为空
            temp=cur.next.next.next;//初始化节点
            firstNode=cur.next;
            secondNode=cur.next.next;

            cur.next=secondNode;//交换位置
            secondNode.next=firstNode;
            firstNode.next=temp;

            cur=firstNode;//最后更新当前节点位置

        }
        return dummyNode.next;//返回头节点


    }
}

时间复杂度:O(n)；（一个while循环为n）

空间复杂度:O(1);（没有使用多余空间）

递归

逻辑与上面的方法相同，其余看代码注释

class Solution {
    public ListNode swapPairs(ListNode head) {
        //递归法
        if(head==null || head.next==null){return head;}//递归结束条件
        ListNode next=head.next;//第二个节点
        ListNode newNode=swapPairs(next.next);
        next.next=head;//将第二个节点的next指向第一个节点
        head.next=newNode;//将第一个节点的next指向换位置递归后第一个节点（也就是第四个节点）
        return next;//以此继续递归
    }
}

时间复杂度:O(n)；（递归一整个链表）

空间复杂度:O(1);（无多余使用空间）

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

题目链接:19.删除链表的倒数第N个节点

大佬视频讲解：删除链表的倒数第N个节点视频讲解

个人思路

这个我有点印象，记得是用双指针，后面咋操作忘记了...菜就多练

解法

双指针

双指针的经典应用；用到快指针fast，慢指针slow；如果要删除倒数第n个节点，先让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。这样slow的位置就是所需要删除节点的前一个节点，最后删掉slow所指向的节点就可以了。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyNode=new ListNode(-1,head);//设置虚拟头结点，方便处理删除实际头结点
        ListNode fast=dummyNode;//快指针
        ListNode slow=dummyNode;//慢指针

        for(int i=0;i<=n;i++){//比慢指针快n个节点
            fast=fast.next;
        }

        while(fast!=null){//当快指针指到末尾时，慢指针的位置就是需要删除元素的位置
            fast=fast.next;
            slow=slow.next;
        }

        slow.next=slow.next.next;//删除元素

        return dummyNode.next;
    }
}

时间复杂度:O(n)；（一个 for循环加上一个while没有嵌套，所以是n+n，2n）

空间复杂度:O(1);（没有使用多余空间）

Leetcode 面试题 02.07. 链表相交

题目链接:面试题 02.07. 链表相交

个人思路

这道题一开始理解起来怪怪的，因为给的例子：listA = [4,1,8,4,5], listB = [5,0,1,8,4,5] 的答案竟然是8，而不是1，后面才发现它还输入了其他几个值skipA = 2, skipB = 3 所以才使得答案是8；（因为LeetCode中输入时有skip的限制，交点不是数值相等，而是指针相等，但最后求得答案还得是根据值相等来判断）

不管怎么样，这道题的关键就是找相交的起始节点，那将这两个链表，末尾相对，一个个遍历即可。

解法

双指针

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA=headA;
        ListNode curB=headB;
        int lenA=0;int lenB=0;

        while(curA!=null){//求链表A长度
            lenA++;
            curA=curA.next;
        }
         while(curB!=null){//求链表B长度
            lenB++;
            curB=curB.next;
        }
        curA=headA;
        curB=headB;
        if(lenA<lenB){//设链表A为最长的链表
            int temp=lenA;
            lenA=lenB;
            lenB=temp;

            ListNode tempNode=curA;
            curA=curB;
            curB=tempNode;
        }
        int gap=lenA-lenB;//计算出链表A和B的长度差
       while(gap-->0){//将链表A的末尾对齐链表B的末尾
           curA=curA.next;
       }

        while(curA!=null){//指针遍历，有相同结果则返回
            if(curA==curB){
                return curA;
            }
            curA=curA.next;
            curB=curB.next;
        }
        return null;
    }
}

时间复杂度:O(n)；（复杂度为n+m ）

空间复杂度:O(1);（没有使用多余空间）

Leetcode 142.环形链表II

题目链接:142.环形链表II

大佬视频讲解：环形链表II 视频讲解

个人思路

这道题可以用快慢指针来解决，快指针fast走2步，慢指针slow走一步，如果有环，快慢指针必定会相交；再使得slow停留再相交点，快指针从头开始，两者同时走一步，这样相交的点就是环的起点。这其中涉及到数学证明，卡哥讲的很详细，可以看看环形链表2

解法

双指针

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;//慢指针
        ListNode fast = head;//快指针
        while (fast != null && fast.next != null) {
            slow = slow.next;//走一步
            fast = fast.next.next;//走两步
            if (slow == fast) {// 判断是否有环
                 // 两个指针，从头结点和相遇结点，各走一步，直到相遇，相遇点即为环入口
                ListNode index1 = fast;
                ListNode index2 = head;
               
                while (index1 != index2) {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;//返回相遇节点
            }
        }
        return null;
    }
}