public ListNode swapPairs(ListNode head) {
        // 设置虚拟头节点
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;
        ListNode prev = dummyNode;
        // 先进行下一个节点的判断， 在进行下下个节点的判断， 避免空指针异常
        while (prev.next != null && prev.next.next != null) {
            // 缓存不变的链表信息（只动两个节点进行位置交换， 将两个节点之后的节点缓存下来）
            ListNode temp = prev.next.next.next;
            // 缓存第一个节点信息（先将第二个节点的位置放到第一个节点的位置上， 第一个节点就没有了节点信息）
            ListNode temp1 = prev.next;
            // 将第二个节点提取到第一个节点的位置
            prev.next = prev.next.next;
            // 将不变的链表放置到 原第一个节点后面
            temp1.next = temp;
            // 将原第一个节点放置到现第二个节点的位置
            prev.next.next = temp1;
            // 链表移动两位
            prev = prev.next.next;
        }
        return dummyNode.next;
    }
复制代码

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
   // 为了方便对头节点操作, 还是使用虚拟头节点 `dummy` 来做
    ListNode dummy = new ListNode(-1);
    dummy.next = head;
    // 创建一个链表 `slow` 表示当前节点
    ListNode slow = dummy;
    // 使用一个链表 `fast` 去获取当前节点后第n个节点
    ListNode fast = dummy;
    // 根据提示可知 n < 链表长度的, 所以使用fast去判断slow节点是不是倒数第n个节点
    while (n-- > 0) {
        fast = fast.next;
    }
    // 记住 待删除节点slow 的上一节点
    ListNode prev = null;
    // 循环终止条件是　`fast` 链表的 next == null
    while (fast != null) {
        // prev 存储当前节点
        prev = slow;
        // slow和fast节点向下进一步
        slow = slow.next;
        fast = fast.next;
    }
    // 循环结束之后, 上一节点是 prev, 下一节点是 slow.next, 删除show节点
    prev.next = slow.next;
    // 下面是看大佬代码的收获
    // 释放 待删除节点slow 的next指针, 这句删掉也能AC
    slow.next = null;
    return dummy.next;
    }
}
复制代码

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 两个链表, 接受 headA和 headB
        ListNode nodeA = headA;
        ListNode nodeB = headB;
        // 记录两个链表的长度
        Integer skipA = 0, skipB = 0;
        // 计算出两个链表的长度
        while(nodeA != null){
            skipA++;
            nodeA = nodeA.next;
        }
        while(nodeB != null){
            skipB++;
            nodeB = nodeB.next;
        }
        // 循环结束之后要重新为两个链表赋值
        nodeA = headA;
        nodeB = headB;
        // 两个链表长度差
        Integer n = skipA - skipB;
        // 让链表A为最长链表, 方便我们后续移动链表操作
        if (skipA < skipB){
            // 交换链表节点
            ListNode node = nodeA;
            nodeA = nodeB;
            nodeB = node;
            // 如果B链表长. 那么长度差是负值, 所以这里要重新进行计算
            n = skipB - skipA;
        }
        // n是长度差, 缩短链表A至长度与B相等
        while(n-- > 0 ){
            nodeA = nodeA.next;
        }
        // 记录返回值
        ListNode node = null;
        // 循环判断链表值是否相等
        while(nodeA != null){
            // 如果两个值相等, 则跳出循环
            if (nodeA == nodeB){
                return nodeA;
            }
            nodeA = nodeA.next;
            nodeB = nodeB.next;
        }
        return null;
    }
复制代码

public static ListNode detectCycle(ListNode head) {
    // 搞两个链表，接收 head
    // A是慢链表，B是快链表
    ListNode nodeA = head;
    ListNode nodeB = head;
    // 判断该链表是否为环形链表
    boolean flag = false;
    while(nodeB != null && nodeB.next != null){
        nodeA = nodeA.next;
        nodeB = nodeB.next.next;
        if (nodeA == nodeB){
            flag = true;
            break;
        }
    }
    // 如果为环形链表，判断入口位置
    if (flag){
        nodeA = head;
        while(nodeA != nodeB){
            nodeA = nodeA.next;
            nodeB = nodeB.next;
        }
        return nodeA;
    }
    return null;
}
复制代码

public static int[] decrypt(int[] code, int k) {
    // 取出当前数组的长度
    int length = code.length;
    // 设置返回值
    int[] ans = new int[length];
    // 如果 k==0 则直接返回， int数组默认元素为 0
    if (k == 0){
        return ans;
    }
    // 初始化总和为 sum = 0， count代表首次计算总和时计算元素的个数，Math.abs（）方法是求取绝对值的
    // 以 k>0 为条件，使用三元运算符动态获取头尾下标
    int sum = 0, count = Math.abs(k), tail = k > 0? 1: 0, head = k > 0? 0 : length-1;
    // 计算 ans[0] 的值
    while(count-- > 0){
        sum += k > 0? code[head = (head + 1) % length] : code[tail = (tail - 1 + length) % length];
    }
    // 赋值
    ans[0] = sum;
    // 循环为 ans数组进行赋值
    for (int i = 1; i < length; i++) {
        // 计算当前下标的 sum值， 同时 head++
        sum += code[++head % length] - code[tail];
        // 赋值
        ans[i] = sum;
        // 计算尾下标
        tail = ++tail % length;
    }
    return ans;
}
复制代码