leetcode 19. Remove Nth Node From End of List

一 题目

Given a linked list, remove the n-th node from the end of list and return its head.

Example:

Given linked list: 1->2->3->4->5, and n = 2.

After removing the second node from the end, the linked list becomes 1->2->3->5.

Note:

Given n will always be valid.

Follow up:

Could you do this in one pass?

二 分析

链表求 删掉从尾节点开始的第N个节点。

2.1 两边遍历法。

虽然题目说能遍历一遍吗？我一开始做想不到，用个笨办法，

第一遍遍历先找到总的个数，第二遍再去处理删除。

一定要注意边界条件，否则容易翻车。代码如下：

public static void main(String[] args) {
		// TODO Auto-generated method stub
		ListNode node1 = new ListNode(1);
		ListNode node2 = new ListNode(2);
		node1.next = node2;
		ListNode node3 = new ListNode(3);
		node2.next = node3;
		ListNode node4 = new ListNode(4);
		node3.next = node4;
		ListNode node5 = new ListNode(5);
		node4.next = node5;
		ListNode res =removeNthFromEnd(node1,2);
		System.out.println( res.val);
		
	}

	 public static ListNode removeNthFromEnd(ListNode head, int n) {
		 
		 int i =1;int j=1;
		 ListNode pre = head;
         //先统计数量
		 while(pre.next != null){
			 i++;
			 pre = pre.next;
		 }
		 if(i==1){
			 return null;
		 }
		 //rule
		
	     pre = head;
	     ListNode dump = head;
		 while(j<=i-n){
			 if(j==i-n){
				 dump.next =(dump.next== null)?null:dump.next.next;
			 }
			 pre = dump;
			 dump = dump.next;
			  
			 j++;
		 }			 
		 if(pre== head && i==n){
			 head = head.next;
		 }
		 
		return head;
	 }
	static class ListNode {
	     int val;
	      ListNode next;
	      ListNode(int x) { val = x; }
}

试着提交一次：LeetCode应该是抽了，

Runtime: 0 ms, faster than 100.00% of Java online submissions for Remove Nth Node From End of List.

Memory Usage: 35 MB, less than 100.00% of Java online submissions forRemove Nth Node From End of List.

这个遍历两边理论上是O（N），还是慢的，达不到题目要求的一遍。

2.2 双指针法

     很多大神上来就指出，这是一道典型的双指针法，贴出来代码，真是佩服。实事求是的说：我感觉自己不够聪明，又没有刻意练习的情况，做不到一下识别出题目的最优解方案。理论上高手是常见的题型都熟悉，知道对应的知识点，也知道怎么一题多解，什么是最优解。目前我还处于开始阶段，加油。

   回到双指针法本身，就是巧妙的使用了N步这个特性，我理解就是数学上那种相对距离吧。网上交快慢指针还是比较形象的。我也沿用这个称呼（或者把快指针理解为指向尾节点，慢指针指向要删除节点）。

  快慢指针都指向head，一开始想让快指针先走n步，然后快慢一起走。直到快指针走到尾节点。这时候把慢指针的next指向跳过节点的下一个节点。

代码如下：

//双指针： 
	 public static ListNode removeNthFromEnd(ListNode head, int n) {
		 ListNode fast = head;
		 ListNode slow = head;
		 
		 //先让快的走n步
		 while(n>0){
			 n--;
			 fast = fast.next;
		 }
		 //边界判断
		 if(fast == null){
			 return head.next;
		 }
		 //一起走
		 while(fast.next !=null){
			 slow = slow.next;
			 fast = fast.next;
		 }
		 slow.next = slow.next.next;
		 return head;		 
	 }

当然LeetCode现在抽了，看不出真实时间消耗了。

Runtime: 0 ms, faster than 100.00% of Java online submissions for Remove Nth Node From End of List.

Memory Usage: 34.9 MB, less than 100.00% of Java online submissions for Remove Nth Node From End of List.

参考：https://www.cnblogs.com/ygh1229/p/9679510.html