1721-交换链表中的节点

给你链表的头节点 head 和一个整数 k 。

交换 链表正数第 k 个节点和倒数第 k 个节点的值后，返回链表的头节点（链表 从 1 开始索引 ）。

示例 1：

![](https://assets.leetcode-cn.com/aliyun-lc-
upload/uploads/2021/01/10/linked1.jpg)

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

示例 2：

**输入：** head = [7,9,6,6,7,8,3,0,9,5], k = 5
**输出：** [7,9,6,6,8,7,3,0,9,5]

示例 3：

**输入：** head = [1], k = 1
**输出：** [1]

示例 4：

**输入：** head = [1,2], k = 1
**输出：** [2,1]

示例 5：

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

提示：

• 链表中节点的数目是 n
• 1 <= k <= n <= 105
• 0 <= Node.val <= 100

解题思路

此处撰写解题思路

代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapNodes(ListNode head, int k) {
        if(k<=0) {
            return null;
        }
        ListNode cur=head;
        ListNode curprev=null;
        ListNode slow=head;
        ListNode slowprev=null;
        ListNode fast=head;
        //目的:找到正数第k个和倒数第k个
        while((k--)-1!=0) {
            fast=fast.next;
            if(fast==null) {
                return null;
            }
            curprev=cur;      //找到cur前一个结点
            cur=cur.next;     //cur走k-1步刚好到正数k的位置
        }
        while(fast.next!=null) {
            slowprev=slow;
            fast=fast.next;
            slow=slow.next;
        }                    //slow就是倒数第k的位置





        ListNode curnext=cur.next;
        ListNode slownext=slow.next;

        ////如果要交换的是相邻的两个结点
        if(cur.next==slow) {   
            if(curprev==null) {    //如果这两个结点相邻并且是头尾节点的情况
                slow.next=cur;
                cur.next=null;
                return slow;
            }
            curprev.next=slow;
            slow.next=cur;
            slowprev.next=null;
            cur.next=slownext;
            return head;
        }
        //这里表示k的值大于链表长度一半是会导致，slow在cur的左边
        if(slow.next==cur) {
            if(slowprev==null) {    //如果这两个结点相邻并且是头尾节点的情况
                cur.next=slow;
                slow.next=null;
                return cur;
            }
            slowprev.next=cur;
            cur.next=slow;
            curprev.next=null;
            slow.next=curnext;
            return head;
        }



        //如果slow没有动，而cur已经走到最后(因为根据上面的逻辑是:cur和fast根据k的值走，如果k等于这个链表的长度那么就会造成这个问题)
        if(slow==head&&slownext!=null) {
            curprev.next=curnext;
            cur.next=slownext;
            curprev.next=slow;
            slow.next=null;
            return cur;
        }


        //如果只有一个结点
        if(slowprev==null) {
            return head;
        }





        slowprev.next=slownext;
        //slow在cur右边时执行的逻辑
        if(curprev==null) {   //表示要交换的是头和尾结点
            slow.next=curnext;
            slowprev.next=head;
            head.next=null;
            return slow;
        }

        //正常逻辑
        curprev.next=curnext;
        curprev.next=slow;
        slow.next=curnext;
        slowprev.next=cur;
        cur.next=slownext;
        return head;
    }
}