这个专题总共有四道题目

206 翻转链表

92  翻转链表某个区间（翻转链表||）

24  两个一组翻转链表

25  k个一组翻转链表

力扣206 翻转链表

其实就是头插法创建一个新链表

总共三个指针，dummy和head这两个指针是肯定是不用说的，无非是多了一个指向head指针下一个结点的temp指针

核心就是下面这两行代码：

head.next=dummy.next;

dummy.next=head;

class Solution
 {
    public ListNode reverseList(ListNode head) 
    {
        if(head==null)  return null;
        ListNode dummy=new ListNode(-1);
        while(head!=null)
        { 
            //temp用来标记这一轮要插入结点的下一个结点（也就是下一轮要插入的结点，要不然下一轮找不到位置）
            ListNode temp=head.next;
           
            //这两行就是头插法插入结点到dummy结点的后面
            head.next=dummy.next;
            dummy.next=head;
 
            head=temp;
        }
        return dummy.next;
    }
}

92.力扣  翻转链表某个区间（翻转链表||）

 反转链表的某个区间

 核心代码：

temp.next=q.next;

q.next=temp

class Solution 
{
    public ListNode reverseBetween(ListNode head, int m, int n) 
    {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
 
        // 初始化指针，一前一后，p在前，q在后，先p后q
        ListNode q = dummy;
        ListNode p = dummy.next;
 
        // p移到第一个要反转的结点位置，q移动到第一个要反转的结点的前一个结点
        for(int i= 0; i < m - 1; i++) 
        {
            p = p.next;
            q = q.next;   
        }
 
        // 头插法插入节点
        for (int i = 0; i < n - m; i++) 
        {
            //存下来p指针后面的结点，将它用头插法插入到q指针后面去
            ListNode temp = p.next;
            
            //从链表中删除刚刚的temp结点
            p.next = p.next.next;
            
            //下面两行代码就是头插法，插入temp结点到g指针指向结点的
            temp.next = q.next;
            q.next = temp;
        }
 
        return dummy.next;
    }

力扣24  两个一组翻转链表

class Solution 
{
    public ListNode swapPairs(ListNode head) 
    {
        ListNode dummy=new ListNode(0);
        dummy.next=head;
 
        ListNode current=dummy;
         
         //交换的是current的后面两个节点
        while(current.next!=null&&current.next.next!=null)
        {
            ListNode p=current.next;
            ListNode q=current.next.next;
            ListNode  temp=current.next.next.next;
 
            current.next=q;
            q.next=p;
            p.next=temp;
            current=p;
        }
        return dummy.next; 
    }
}

力扣 25  k个一组翻转链表

​

 注意两点：

（1）先把prev指针和end指针的位置确定好，然后start=prev.next即可,next=end.next即可

（2）一轮之后，prev=start(此时start和end的位置是start在右边，end的位置在左边)

end=prev（这就又把下轮的prev和end位置确定好了）

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) 
    {
        ListNode dummy=new  ListNode(0);
        dummy.next=head;

        ListNode prev=dummy;
        ListNode end=dummy;

        while(end.next!=null)
        {
            for(int i=0;i<k&&end!=null;i++)//找到end指针的位置
            {
               end=end.next;
            }

            if(end==null)     break;//不足k个结点，这k个结点不用反转

            ListNode start=prev.next;
            ListNode next=end.next;

            end.next=null;//断开end指针

            prev.next=reverse(start);//将start-end区间进行反转

            start.next=next;//重新将链表连起来

            prev=start;//此时end指针在左，start指针在右
            end=prev;
        }
        return dummy.next;
    }

    public  ListNode  reverse(ListNode  head)
    {
       ListNode  dummy=new ListNode(-1);
       dummy.next=null;
       
       while(head!=null)
       {
           ListNode   p=head.next;
           head.next=dummy.next;
           dummy.next=head;
           head=p;
       }
       return   dummy.next;
    }
}