牛客网top101（第9题，删除链表的倒数第n个节点，10题，两个链表的第一个公共节点，11题，链表相加）

删除链表的倒数第n个节点

第9题 删除链表的倒数第n个节点
第10题 两个链表的第一个公共节点
第11题 链表相加

import java.util.*;
public class Solution {
    public ListNode removeNthFromEnd (ListNode head, int n) {
        //添加表头 fast-template
        ListNode res = new ListNode(-1);
        res.next = head;
        //当前节点
        ListNode cur = head;
        //前序节点
        ListNode pre = res;
        ListNode fast = head;
        //快指针先行n步
        while(n != 0){
            fast = fast.next;
            n--;
        }
        //快慢指针同步，快指针到达末尾，慢指针就到了倒数第n个位置
        while(fast != null){
            fast = fast.next;
            pre = cur;
            cur = cur.next;
        }
        //删除该位置的节点
        pre.next = cur.next;
        //返回去掉头
        return res.next;}
}

第10 题 两个链表的第一个公共节点

两个链表的第一个公共节点


思路1：可能比较容易想到，但是我是真不推荐，因为写的代码太多了，
可能有点难写出来。
如果两个链表有公共节点，那么它们后半部分都是相同的，我们要找的也就是后半部分的第一个节点，只要遍历两个指针同时抵达第一个相同的节点，我们就找到了它。

step 1：单独的遍历两个链表，得到各自的长度。
step 2：求得两链表的长度差n，其中较长的链表的指针从头先走n步。
step 3：两链表指针同步向后遍历，遇到第一个相同的节点就是第一个公共结点。
方法2：
思路:
使用两个指针N1,N2，一个从链表1的头节点开始遍历，我们记为N1，一个从链表2的头节点开始遍历，我们记为N2。

让N1和N2一起遍历，当N1先走完链表1的尽头（为null）的时候，则从链表2的头节点继续遍历，同样，如果N2先走完了链表2的尽头，则从链表1的头节点继续遍历，也就是说，N1和N2都会遍历链表1和链表2。

因为两个指针，同样的速度，走完同样长度（链表1+链表2），不管两条链表有无相同节点，都能够到达同时到达终点。

（N1最后肯定能到达链表2的终点，N2肯定能到达链表1的终点）。

所以，如何得到公共节点：

• 有公共节点的时候，N1和N2必会相遇，因为长度一样嘛，速度也一定，必会走到相同的地方的，所以当两者相等的时候，则会第一个公共的节点
• 无公共节点的时候，此时N1和N2则都会走到终点，那么他们此时都是null，所以也算是相等了。
  下面看个动态图，可以更形象的表示这个过程~

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode l1 = pHead1,l2 = pHead2;
        while (l1 != l2) {
            l1 = (l1 == null)?pHead2:l1.next;
            l2 = (l2 == null)?pHead1:l2.next;
        }
        return l2;
    }
}

第11题 链表相加

链表相加


解题思路：
假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。
我们知道题目已经限定了每个节点的值都不为负数了，所以我们就可以不考虑符号的问题了，那么就很简单了。
我们先看一下题目给的例子：

例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。
从这个例子我们可以得到：

1. 两个链表的长度可能不等，需要对齐
2. 相加后可能需要进位
   对齐进位
   因为我们无法保证两个链表长度一致，所以我们干脆从后往前对齐，跟我们整数再做加法一样
   
   使用反转链表:
   所以我们的入手则是对链表进行对齐，我们可以看到上面的图片，我们都是从后面开始对齐与计算的，所以很容易想到反转链表后进行相加。

代码：

public ListNode addInList (ListNode head1, ListNode head2) {
        // 进行判空处理
        if(head1 == null)
            return head2;
        if(head2 == null){
            return head1;
        }
        // 反转h1链表
        head1 = reverse(head1);
        // 反转h2链表
        head2 = reverse(head2);
        // 创建新的链表头节点
        ListNode head = new ListNode(-1);
        ListNode nHead = head;
        // 记录进位的数值
        int tmp = 0;
        while(head1 != null || head2 != null){
            // val用来累加此时的数值（加数+加数+上一位的进位=当前总的数值）
            int val = tmp;
            // 当节点不为空的时候，则需要加上当前节点的值
            if (head1 != null) {
                val += head1.val;
                head1 = head1.next;
            }
            // 当节点不为空的时候，则需要加上当前节点的值
            if (head2 != null) {
                val += head2.val;
                head2 = head2.next;
            }
            // 求出进位
            tmp = val/10;
            // 进位后剩下的数值即为当前节点的数值
            nHead.next = new ListNode(val%10);
            // 下一个节点
            nHead = nHead.next;

        }
        // 最后当两条链表都加完的时候，进位不为0的时候，则需要再加上这个进位
        if(tmp > 0){
            nHead.next = new ListNode(tmp);
        }
        // 重新反转回来返回
        return reverse(head.next);
    }

    // 反转链表
    ListNode reverse(ListNode head){
        if(head == null)
            return head;
        ListNode cur = head;
        ListNode node = null;
        while(cur != null){
            ListNode tail = cur.next;
            cur.next = node;
            node = cur;
            cur = tail;
        }
        return node;
    }

我是test