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

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

迭代

        基本思路：遍历链表，使用三个变量存储前中后三个节点（pre，first，second），pre的初始值为虚拟节点，pre的含义为已经交换完毕的节点的最后一个节点。写一个while循环，循环条件为pre的next或者next的next不为空。循环内部：

（1）new一个新的节点next，用来存放当前三个节点的下一个节点，也就是pre.next.next.next

（2）给first，second节点赋值，first = pre.next；second = pre.next.next

（3）进行交换操作：

        步骤一：pre.next = second；（将second放到pre的后面）

        步骤二：second.next = first；（将firs放到second的后面）

        步骤三：first.next = next；（first的后面接上剩余的链表头）

        步骤四：pre = first；（pre指向翻转完毕链表的尾节点）

 循环结束，返回虚拟节点的next。

Java代码如下：

 public ListNode swapPairs(ListNode head) {
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;
        ListNode pre = dummyNode;
        ListNode temp;
        ListNode firstNode;
        ListNode secondNode;
        while(pre.next != null && pre.next.next != null)
        {
            temp = pre.next.next.next;
            firstNode = pre.next;
            secondNode = pre.next.next;
            pre.next = secondNode;
            secondNode.next = firstNode;
            firstNode.next = temp;
            pre = firstNode;
        }

        return dummyNode.next;
 }

递归

        基本思路：递归到链表的结尾，每次递归两个节点，到达链表末尾之后，反转保存的两个节点，再将新的反转之后的链表返回给上一个函数，处理这个函数保存的两个节点，直到链表结束，返回新的链表。

Java代码如下：

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;
        head.next = newNode;

        return next;
    }

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

         基本思路：使用快慢指针，快指针先走n步，然后慢指针再走，当快指针到达链表结尾的时候，慢指针就刚好到达倒数第N个节点的前一个节点（慢指针走的步数为链表长度 - n），然后直接删除即可。

Java代码如下：

public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;
        ListNode fast = dummyNode;
        ListNode slow = dummyNode;
        int index = 0;
        while(fast != null && fast.next != null)
        {
            if(index >= n)
            {
              slow = slow.next;
            }
            fast = fast.next;
            index++;
        }
        
        slow.next = slow.next.next;
        
        return dummyNode.next;
}

面试题02.07.链表相交

        基本思路：算得两个链表长度的差值，长的那个链表先走差值那么多步，然后两个链表再一起移动，当两个节点的引用值相等的时候，就找到了第一个相交节点，直接返回。

Java代码如下：

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int length_A = 0;
        int length_B = 0;
        ListNode nodeA = headA;
        ListNode nodeB = headB;
        int distance = 0;
        while(nodeA != null)
        {
            nodeA = nodeA.next;
            length_A++;
        }
        while(nodeB != null)
        {
            nodeB = nodeB.next;
            length_B++;
        }
        nodeA = headA;
        nodeB = headB;
        distance = Math.abs(length_A - length_B);
        if(length_A > length_B)
        {
            for(int i = 0 ; i < distance ; i++)
            {
                nodeA = nodeA.next;
            }
        }else{
            for(int i = 0 ; i < distance ; i++)
            {
                nodeB = nodeB.next;
            }
        }
        while(nodeA != nodeB)
        {
            nodeA = nodeA.next;
            nodeB = nodeB.next;
        }
        
        return nodeA;
}

LeetCode.142 环形链表Ⅱ

        基本思路：快慢指针，快指针走两步，慢指针走一步，如果链表有环，那么两个指针早晚会在环里相遇，当第一次相遇，fast回到head位置，然后和慢指针一起一次走一步，当他们两个第二次相遇的时候，当前节点就是环的入口节点。

为什么呢？假设链表长度为 a + b （a表示到环入口需要多少步，b表示环内有多少步）

有快指针一次走两步，慢指针一次走一步可以得，f = 2s（f为快指针走了步数，s为慢指针走的步数），当两个指针的第一次相遇的时候，快指针肯定是比慢指针多走了n圈，得出 f = s + nb），由两式得出，f = 2nb , s = nb。

f 的总步数为 a + nb，s的总步数为nb，需要再让s走a步，就能达到环入口，但是我们不知道a是多少，我们就可以把fast指针指向head，然后两个指针一起走，一次走一步，当两个指针引用相等的时候，说明走了a步，到达了环的入口（fast指向head之后需要a步到达环入口，而slow也需要a步到达环入口），直接返回fast或者slow节点即可。

Java代码如下：

public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(true)
        {
            if(fast == null || fast.next == null)
            {
                return null;
            }
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow)
            {
                break;
            }
        }
        fast = head;
        while(fast != slow)
        {
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
}