代码随想录第四天|交换节点、删除节点、链表相交、环形链表

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

题目链接: 两两交换链表中的节点
自己的思路:迭代和递归。迭代：以链表1–>2–>3–>4–>5–>null为例，定义一个虚拟头结点，可以避免很多边界判断，定义一个临时结点cur=dummyhead，cur位于需要调换的两个结点的前面一个结点，首先改变虚拟头结点cur的指向，即cur.next=2，然后改变2.next=1，进而改变1.next=3，这样就可以完成一个小单元的迭代，所以需要存一下1和3的临时结点，然后cur需要前移两个位置才可以，因为cur必须位于需要调换的两个结点的前面一个结点，然后重复此过程。

正确思路:迭代、递归

迭代代码:

/**
 * 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 Solution {
    public ListNode swapPairs(ListNode head) {
        //定义一个虚拟头结点
        ListNode dummyhead = new ListNode(0,head);
        ListNode cur = dummyhead;
        //因为迭代的过程中存在cur.next.next.next，所以cur.next.next不可以为null
        while(cur.next!=null&&cur.next.next!=null){
            //定义两个临时结点
            ListNode temp1 = cur.next;
            ListNode temp2 = cur.next.next.next;
            //改变指向
            cur.next = cur.next.next;
            cur.next.next = temp1;
            temp1.next = temp2;
            cur = cur.next.next;
        }
        //返回新的链表的头结点
        return dummyhead.next;
    }
}

复杂度分析：
时间复杂度：$\mathcal{O}(n)$
空间复杂度：$\mathcal{O}(1)$

递归思路:始终记住递归函数的作用是交换两个链表的结点。
递归代码:

/**
 * 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 Solution {
    public ListNode swapPairs(ListNode head) {
        //终止条件
        if (head==null||head.next==null) return head;
        //始终记住swapPairs是交换两个链表的结点
		//假设链表是 1->2->3->4
		//保存节点2
		ListNode temp = head.next;
		//继续递归，处理节点3->4
		//当递归结束返回后，就变成了4->3
		//于是head节点就指向了4，变成1->4->3
		head.next = swapPairs(temp.next);
		//将2节点指向1
		temp.next = head;
        return temp;
    }
}

复杂度分析：
时间复杂度：$\mathcal{O}(n)$
空间复杂度：$\mathcal{O}(1)$

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

题目链接: 删除链表的倒数第 N 个结点
自己的思路:可以假设一个虚拟头结点，避免一些边界的判断。采用双指针的方法来处理，定义一个快指针为虚拟头结点先在前面走，走n+1步之后，再让慢指针和快指针同时走，直到快指针为null为止，慢指针就可以指向倒数第n个结点之前的一个结点。分析原理：假设链表长度为l，快指针先走n+1步的话，则剩下要走的步数为l-n-1，慢指针走l-n-1步之后，就会剩下n+1个结点，那么慢指针就在要删除的结点之前。
正确思路:双指针

代码:

/**
 * 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 Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //新建一个虚拟头结点
        ListNode dummyhead = new ListNode(0,head);
        ListNode fast = dummyhead;
        //先让fast指针走n+1步，这样可以让slow指向要删除的结点的前一个
        while(n!=0&&fast!=null){
            fast = fast.next;
            n--;
        }
        fast = fast.next;
        //fast指针走完n+1步，slow指针再开始走
        ListNode slow = dummyhead;
        while(fast!=null){
            fast = fast.next;
            slow = slow.next;
        }
        //删除节点
        slow.next = slow.next.next;
        //返回头结点
        return dummyhead.next;
    }
}

复杂度分析：
时间复杂度：$\mathcal{O}(n)$
空间复杂度：$\mathcal{O}(1)$

Leetcode 面试题 02.07 链表相交

题目链接: 链表相交
自己的思路:假设两个链表存在交点，链表A单独的链表长度为a，链表B单独的链表长度为b，共同的链表长度为c，那么定义两个指针，heada指针初始化为headA结点，headb指针初始化为headB结点，先让heada指针遍历一遍链表A，然后再让heada指针走一遍链表B单独的链表，则遍历的链表总长度为a+c+b；同理，headb指针遍历的链表总长度为b+c+a；走的路径数相等，所以最后停的时候就是两个链表的交点。

正确思路:双指针

代码:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode heada = headA;
        ListNode headb = headB;
        while(heada!=headb){
            //结点遍历
            heada = heada==null?headB:heada.next;
            headb = headb==null?headA:headb.next;
        }
        return heada;
    }
}

复杂度分析：
时间复杂度：$\mathcal{O}(a+b)$
空间复杂度：$\mathcal{O}(1)$

Leetcode 142 环形链表 II

题目链接: 环形链表 II
自己的思路:该题记住结论即可，三指针寻找环形链表入口。先定义快慢指针来寻找两个指针的交点，然后定义一个临时结点，慢指针和临时结点同时走，交点即为环形链表的入口。

正确思路:三指针。

代码:

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
    	//定义快慢指针
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            //快慢指针交点
            if (fast==slow){
                ListNode cur = head;
                //找环形链表入口
                while(cur!=slow){
                    slow = slow.next;
                    cur = cur.next;
                }
                return slow;
            }
        }
        return null;
    }
}

复杂度分析：
时间复杂度：$\mathcal{O}(n)$
空间复杂度：$\mathcal{O}(1)$