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

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

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

示例 1：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/swap-nodes-in-pairs

 给链表构造虚拟头结点，指针cur指向构造虚拟头结点后的链表，通过改变指针的指向实现节点交换。临时节点t1保存cur.next，t2保存cur.next.next.next，cur.next=cur.next.next，cur.next=t1，t1.next=t2，完成第一个交互后cur指向下下个指针，进行下一个位置的交换。

 public ListNode swapPairs(ListNode head) {
        ListNode dummyhead=new ListNode();
        dummyhead.next=head;
        ListNode cur=dummyhead;
		while(cur.next!=null&&cur.next.next!=null) {
			ListNode temp1=cur.next;
			ListNode temp2=temp1.next.next;
		    cur.next=cur.next.next;	  
		    cur.next.next=temp1;
		    temp1.next=temp2;
		    cur=cur.next.next;
        }
        return dummyhead.next;
    }

 

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

   

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

示例 1：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list

构造虚拟头结点dummyhead，两个指针fast，slow都指向dummyhead，fast先走n步，slow再和fast一起走，直到fast走到链表的最后一个节点，此时slow走了size-n步，slow的下一个节点就是要删除的节点，slow.next=slow.next.next，返回虚拟头结点的下一个节点dummyhead.next。

 

public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyhead=new ListNode();
		dummyhead.next=head;
        ListNode slow=dummyhead,fast=dummyhead;  
		while(n-->0) {
            fast=fast.next;  
        }
		while(fast.next!=null) {
			fast=fast.next;
			slow=slow.next;
		}
		slow.next=slow.next.next;
		return dummyhead.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 个节点。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci

先找出两个链表的长度，求出长度差，把较长的链表一直指向下一个指针ha=ha.next，直到两个链表的长度一致，比较两个链表是否相等，如果直到链表的最后一个节点两个链表都不相等，返回null。

 public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode ha=headA;
    	ListNode hb=headB;
    	int counta=0,countb=0;
    	//找出两个链表的长度
    	while(ha!=null) {
    		counta++;
    		ha=ha.next;
    	}
    	while(hb!=null) {
    		countb++;
    		hb=hb.next;
    	}
    	//长的链表对齐到短链表的位置
    	ha=headA;
    	hb=headB;
    	if(counta>countb) {
    		int t=counta-countb;		
    		while(t-->0) {
    			ha=ha.next;
    		}
    	}else {
    		int t=countb-counta;		
    		while(t-->0) {
    			hb=hb.next;
    		}
    	}
		while(hb!=null) {
			if(ha==hb) return ha;
			ha=ha.next;hb=hb.next;
		}
    	return null;
    }

 142.环形链表II

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

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

不允许修改 链表。

 

示例 1：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/linked-list-cycle-ii

 定义两个指针，slow和fast，起点一样，slow每次走一步，fast每次走两步，当链表有环时，两个指针一定会在环中相遇，而且当slow还没走完一圈两个指针就相遇了。从起点到环入口的距离设为x，入口到两个指针相遇的距离为y，相遇点到入口的距离为z，slow走了x+y，fast走了x+y+n(y+z)，n为两个指针相遇前fast指针走过的环的圈数，fast走的距离是slow的两倍，有2(x+y)=x+y+n(y+z)，题目求的是环的入口x，等式化简后有x=(n-1)(y+z)+z，说明slow跟fast相遇后，一个指针从链表头部出发，一个指针从相遇点出发，两个指针必定会在链表开始入环的第一个节点相遇。

 

 

 public ListNode detectCycle(ListNode head) {
      ListNode slow=head,fast=head;
	   while(fast!=null&&fast.next!=null) {
		   slow=slow.next;
		   fast=fast.next.next;
		   if(slow==fast) {
			   ListNode l1=head,l2=slow;
			   while(l1!=l2) {
				   l1=l1.next;
				   l2=l2.next;
			   }
			   return l2;
		   }
	   }    
	   return null;
    }