第四天||24. 两两交换链表中的节点 ● 19.删除链表的倒数第N个节点 ● 面试题 02.07. 链表相交 ● 142.环形链表II

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

中等

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

示例 1：

图片

输入：head = 1,2,3,4

输出：2,1,4,3

示例 2：

输入：head = \[\]

输出：\[\]

示例 3：

输入：head = 1

输出：1

提示：

• 链表中节点的数目在范围 0, 100 内
• 0 <= Node.val <= 100

代码

/**

• Definition for singly-linked list.

• struct ListNode {

  int val;

  ListNode *next;

  ListNode() : val(0), next(nullptr) {}

  ListNode(int x) : val(x), next(nullptr) {}

  ListNode(int x, ListNode *next) : val(x), next(next) {}

• };
  /
  class Solution {
  public:
  ListNode swapPairs(ListNode* head) {

  // 如果链表为空或者只有一个节点，无需交换，直接返回

  if (head == NULL || head->next == NULL) {

  return head;

  }

   // 新建一个哑节点(dummy)，使它成为新的头节点，方便处理头节点的交换
   ListNode* dummy = new ListNode(0);
   dummy->next = head;
   ListNode* prev = dummy; // prev指向要交换的一对节点前面的节点
  
   while (head != NULL && head->next != NULL) {
       ListNode* first = head;
       ListNode* second = head->next;
  
       // 交换节点
       prev->next = second;
       first->next = second->next;
       second->next = first;
  
       // 更新prev和head
       prev = first;
       head = first->next;
   }
  
   // 返回新的头节点，即哑节点(dummy)的下一个节点
   return dummy->next;

  }

  };

func swapPairs(head *ListNode) *ListNode {

res := &ListNode{

Next: head,

}

p := head

for i := res; i != nil && i.Next != nil && i.Next.Next != nil; i = p {

p = i.Next

q := p.Next

//swap

p.Next = q.Next

q.Next = p

i.Next = q

}

return res.Next

}

思考：

• 不思考，直接学习这个思路

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

中等

给你一个链表，删除链表的倒数第 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

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

进阶：你能尝试使用一趟扫描实现吗？

代码

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    //第一遍计数，第二遍数到n
    listNum := 0
    for i := head; i != nil; i = i.Next {
        listNum++
    }
    res:=&ListNode{
        Next: head,
    }
    //删除第listNum-n+1个，找到listNum-n+2
    for i, j := res, 0; i != nil; i = i.Next {
        if j == listNum-n {
            i.Next = i.Next.Next
        }
        j++
    }
    return res.Next
}

面试题 02.07. 链表相交

简单

给你两个单链表的头节点 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 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 0 <= m, n <= 3 * 10(4)
• 1 <= Node.val <= 10(5)
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listAskipA + 1 == listBskipB + 1

进阶：你能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？

代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
	for i:=headA;i!=nil;i=i.Next{
		for j:=headB;j!=nil;j=j.Next{
			if i==j{
				return i
			}
		}
	}
	return nil
}

142. 环形链表 II

中等

给定一个链表的头节点 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

解释：链表中没有环。

提示：

• 链表中节点的数目范围在范围 0, 10(4) 内
• -10(5) <= Node.val <= 10(5)
• pos 的值为 -1 或者链表中的一个有效索引

进阶：你是否可以使用 O(1) 空间解决此题？

代码

func detectCycle(head *ListNode) *ListNode {
	//快慢指针
	if head == nil || head.Next == nil {
		return nil
	}
	p, q := head, head
	for q != nil && q.Next != nil {
		p, q = p.Next, q.Next.Next
		if p == q { //有环
			i, j := head, p
			for i != j {
				i = i.Next
				j = j.Next
			}
			return i
		}
	}
	return nil

}

思考

• 从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。