《代码随想录》Day04打卡

《代码随想录》链表：两两交换链表中的节点

本题题目如下：

本题有两种解法，分别是迭代法和递归法： 1.迭代法：

//24. 两两交换链表中的元素-迭代法
class Solution4 {
    public ListNode swapPairs(ListNode head) {
        ListNode temp, dummyHead = new ListNode(0);//设置一个虚拟头节点
        dummyHead.next = head;
        temp = dummyHead;
        while(temp.next != null && temp.next.next!=null){
            ListNode node1 = temp.next;
            ListNode node2 = temp.next.next;
            temp.next = node2;//这一步很重要，是当时没有想到的，这一步是将交换后的第二个元素与即将交换的一组元素的第一个元素（这个第一个指的是交换后的第一个）连接起来
            node1.next = node2.next;//执行交换动作
            node2.next = node1;
            temp = node1;//交换后的第二个节点就是node1
        }
        return dummyHead.next;
    }
}

2.递归法：

//24. 两两交换链表中的元素-递归法
class Solution5 {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode newHead = head.next;
        head.next = swapPairs(newHead.next);
        newHead.next = head;
        return newHead;
    }
}

《代码随想录》链表：删除链表的倒数第N个节点

本题完整题目如下：

本题，可以先计算该链表的节点的数目，然后将倒数转化为正数，这样就跟删除链表中的第几个节点一样的操作了，较为简单。 完整代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution6 {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //1.先计算出链表的长度
        int size = 0;
        ListNode temp = head;
        while(temp != null){
            size ++;
            temp = temp.next;
        }
        temp = head;
        //假设一个虚拟头节点
        ListNode dummdyNode = new ListNode(0);
        dummdyNode.next = head;
        if(size==1){
            return null;
        }
        //删除倒数第n个节点就是删除正数第size-n+1个节点
        int index = size - n + 1;//计算出要删除的节点
        ListNode pre = head;
        //如果index为1，代表要删除的是头节点，测试直接将虚拟头节点的下一个节点指向头节点的下一个节点
        if(index == 1){
            dummdyNode.next = head.next;
        }else{
            for(int i = 0;i < index - 1;i++){
                pre = temp;
                temp = temp.next;
            }
            pre.next = temp.next;
        }
        return dummdyNode.next;
    }
}

《代码随想录》链表：链表相交

完整题目如下：

本题目也比较简单，所以完整代码如下：

//160.链表相交
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution7 {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int skipA = 0;
        ListNode tempA = headA;
        while(tempA != null){
            int skipB = 0;
            ListNode tempB = headB;
            if(tempB == null){
                return null;
            }
            while(tempA != tempB && tempB != null){
                tempB = tempB.next;
                if(tempB == null){
                    break;
                }
                skipB++;
            }
            if(tempA == tempB){
                return new ListNode(tempA.val);
            }else{
                tempA = tempA.next;
                skipA++;
            }
​
        }
        return null;
    }
}

《代码随想录》链表：环形链表II

本题目完整题目如下：

本题较为困难，主要是理解思想，代码写起来比较简单，分为两步： 1.判断该链表是否有环：使用双指针法，一个快指针，一个慢指针，其中快指针一次移动两个节点，慢指针一次移动一个节点，当存在环时，则这两个指针终将相遇，反之则一定不会相遇。 2.判断存在环后，接下来就是找到环的入口：当两个指针相遇时，再假设有一个指针从头节点出发，该指针和慢指针在相遇时的那个节点就是环的入口。 对于上述过程不理解的，可以观看《代码随想录》的讲解视频，讲的比较清晰。 完整代码如下：

public class Solution8 {
        public ListNode detectCycle(ListNode head) {
            //快慢指针法
            ListNode fast = head;
            ListNode slow = head;
            if(head == null){
                return null;
            }
            //判断是否有环的依据就是看这两个指针是否会相遇
            while(fast != null){
                if(fast.next != null){
                    fast = fast.next.next;
                }else{
                    return null;
                }
                slow = slow.next;
                if(fast == slow){
                    ListNode temp = head;
                    if(temp == slow){
                        return temp;
                    }else{
                        while(temp != slow){
                            temp = temp.next;
                            slow = slow.next;
                        }
                        return temp;
                    }
                }
            }
            return null;
        }
    }
}

《代码随想录》链表：链表总结篇

本章节，将虚拟头节点的使用掌握是最重要的，还有就是最后一道题环形链表Ⅱ，要将思想理解，代码就比较简单，具体链表的知识点详见链表基础部分！