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

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

思路:

public static ListNode SwapPairs(ListNode head)
        {
            ListNode dummyHead = new ListNode(0, head);//虚拟头结点
            ListNode cur = dummyHead;
            while (cur.next != null && cur.next.next != null)//结束条件
            {
                ListNode tmp1 = cur.next;
                ListNode tmp2 = cur.next.next.next;
                cur.next = cur.next.next;//赋值顺序
                cur.next.next = tmp1;
                tmp1.next = tmp2;
                cur = cur.next.next;
            }
            return dummyHead.next;
        }

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

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

思路:
双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。
推荐使用虚拟头结点。

public static ListNode RemoveNthFromEnd(ListNode head, int n)
        {
            ListNode dummyHead = new ListNode(0, head);
            int i = 1;
            ListNode fast = dummyHead;
            ListNode slow = dummyHead;
            while (i++ <= n) //使用虚拟头结点时，走到第n个结点。
            {
                fast = fast.next;
            }
            while (fast.next != null)
            {
                fast = fast.next;
                slow = slow.next;
            }
            slow.next = slow.next.next;
            return dummyHead.next;
        }

160. 相交链表

思路: 求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置。

public static ListNode GetIntersectionNode(ListNode headA, ListNode headB)
        {
            ListNode dummyHeadA = new ListNode(0, headA);
            ListNode curA = dummyHeadA;
            ListNode dummyHeadB = new ListNode(0, headB);
            ListNode curB = dummyHeadB;
            int lenA = 1;
            int lenB = 1;
            while (curA.next != null)//使用虚拟头结点时，计算链表长度
            {
                lenA++;
                curA = curA.next;
            }
            while (curB.next != null)
            {
                lenB++;
                curB = curB.next;
            }
            curA = dummyHeadA;
            curB = dummyHeadB;

            if (lenA > lenB)
            {
                int diff = lenA - lenB;
                int n = 1;
                while (n++ <= diff + 1)//使用虚拟头结点时，走到第n个结点。
                {
                    curA = curA.next;
                }
                curB = curB.next;
            }
            else
            {
                int diff = lenB - lenA;
                int n = 1;
                while (n++ <= diff + 1)
                {
                    curB = curB.next;
                }
                curA = curA.next;
            }
            while (curA != null)
            {
                if (curA == curB) return curA;
                else {
                    curA = curA.next;
                    curB = curB.next;
                }
            }
            return null;
        }