3、链表（上）

1、删除链表的倒数第N个节点

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

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.

进阶：

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

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        //由于第一个节点有可能被删除，所以需要设置一个dummy节点
        ListNode p = dummy, q = dummy;
        while (n-- > 0 && q != null) {
            q = q.next;
        }
        while (q.next != null) {
            p = p.next;
            q = q.next;
        }
        p.next = p.next.next;
        return dummy.next;
    }
}

链表类的题目最好画图提供代码思路。

2、删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

node的next节点覆盖该节点。

3、删除排序链表中的重复元素 I

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        //删除排序链表中的重复元素，因为永远不会删除head节点，所以不需要设置dummy节点
        ListNode cur = head;
        while (cur != null && cur.next != null) {
            if (cur.val == cur.next.val) cur.next = cur.next.next;
            else cur = cur.next;
        }
        return head;
    }
}

3、删除排序链表中的重复元素 II

给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        //由于该题的删除方式有可能会删除第一个节点
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode slow = dummy;
        while (slow.next != null) {
            //slow指向上一次完整结果中的最后一个节点，由本次循环来决定，slow.next应该指向那个节点
            ListNode fast = slow.next;
            while (fast != null && slow.next.val == fast.val) {
                fast = fast.next;
            }
            if (slow.next.next == fast) {
                slow = slow.next;
            } else {
                slow.next = fast;
            }
        }
        return dummy.next;
    }
}

4、旋转链表

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

1、

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        //排除特殊情况
        if (head == null || head.next == null) return head;
        //链表连接成环，寻找链表的尾结点
        ListNode cur = head;
        int len = 1;
        //链表的节点数
        while (cur.next != null) {
            cur = cur.next;
            len++;
        }
        //此时cur指向链表尾结点
        cur.next = head;
        cur = head;
        //重新指向head节点
        for (int i = 0; i < len - 1 - k % len; i++) {
            cur = cur.next;
        }
        head = cur.next;
        //记录下新的链表节点
        cur.next = null;
        return head;
    }
}

2、双指针（推荐）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if (head == null || head.next == null) return head;
        ListNode cur = head;
        int len = 0;
        while (cur != null) {
            len++;
            cur = cur.next;
        }
        k %= len;
        ListNode first = head, second = head;
        while (k-- > 0) first = first.next;
        while (first.next != null) {
            first = first.next;
            second = second.next;
        }
        first.next = head;
        head = second.next;
        second.next = null;
        return head; 
    }
}

first指针和second指针差K，那么当first指针到达尾结点时，second指针指向倒数K+1个节点。

5、两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

给定 1->2->3->4, 你应该返回 2->1->4->3.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        //反转节点后，head就不是head了，所以需要一个dummy节点
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        for (ListNode p = dummy; p != null && p.next != null && p.next.next != null; p = p.next.next) {
            ListNode a = p.next, b = a.next;
            a.next = b.next;
            b.next = a;
            p.next = b;
        }
        return dummy.next;
    }
}