LeetCode 24 两两交换链表节点、 19删除链表的倒数第 N 个结点、链表相交（面试）、142环形列表

 24

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

 

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

class Solution {
public:
	ListNode* swapPairs(ListNode* head) {
		ListNode* Shead=new ListNode();
		Shead->next = head;
		ListNode* cur = Shead;

		while (cur->next != NULL && cur->next->next != NULL) {
			ListNode* tmp = cur->next->next->next;
			ListNode* tmp1 = cur->next;

			cur->next = cur->next->next;
			cur->next->next = tmp1;
			cur->next->next->next = tmp;

			cur = cur->next->next;
		}
		return Shead->next;
	}
};

此题微微有点绕，所以一定要理清思路，尤其注意 某些节点的暂保存，因为在cur指针的操作过程中，很多指针的指向已经变化：

 

 可以参考以上的步骤进行交换；先聚焦第一二个节点的变换：一开始cur指向虚头节点，根据第一次变化后的链表，可知cur->next应该指向B节点，也就是cur->next->next,这是第一步，操作完后，链表的节点指向就开始发生变化了；第二步是B节点指向A节点，但是要注意！！！！！此时的S节点已经不是cur->next了，但是要表示各个节点只能通过cur指针，所以我们只能在没有任何指针操作前将此节点保存下来（tmp1），同理C节点也是如此，也要提前保存。

理清了交换节点的步骤和指针的保存，这道题基本上就没啥了~

29 

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

class Solution {
public:
	ListNode* removeNthFromEnd(ListNode* head, int n) {
		ListNode* Shead=new ListNode();
		Shead->next = head;
		ListNode* pre = Shead;
		ListNode* aft = Shead;
		while (n--) {
			aft = aft->next;
		}
		while (aft->next != NULL) {
			aft = aft->next;
			pre = pre->next;
		}
		pre->next = pre->next->next;
		return Shead->next;
	}
};

这道题重点在“倒数”，用双指针就做出来啦

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
		int lenA = 0;
		int lenB = 0;
		ListNode* SheadA=new ListNode();        
        ListNode*SheadB=new ListNode();
		ListNode* cur1,* cur2;
		SheadA->next = headA;
		SheadB->next = headB;
		cur1 = SheadA;
		cur2 = SheadB;
		while (cur1->next != NULL) {
			lenA++;
			cur1 = cur1->next;
		}
		while (cur2->next != NULL) {
			lenB++;
			cur2 = cur2->next;
		}
		//必须先重置cur1,cur2
		cur1 = headA;
		cur2 = headB;
		//确保cur1是操作长链表的，lenA是长链表的长度
		if (lenA < lenB) {
			swap(lenA, lenB);
			swap(cur1, cur2);
		}
		int gap = lenA - lenB;		
		while (gap--) {
			cur1 = cur1->next;
		}
		while (cur1 != NULL && cur2 != NULL) {
            if (cur1 == cur2) { return cur1; }
			cur1 = cur1->next;
			cur2 = cur2->next;
			
		}
		return NULL;
    }
};

此题没什么难点，主要是先算出两个链表在长度差值，然后注意相交结点椒cur1==cur2在时候，而不是数值val相等~ 

142

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

正在上传…重新上传取消正在上传…重新上传取消

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

思路总结：设置两个指针pre,fast，一开始都指向头节点，然后开始循环，pre一步一步往前，fast两步两步往前，若该链表存在，那么这两个指针一定会相遇；此时记录下相遇结点，再设一个结点指向head，两个指针同时前进，相遇结点即为环的起始结点~

具体解释如卡哥（代码随想录）所示：代码随想录（卡哥）