Reverse Nodes In K Group，将链表每k个元素为一组进行反转---特例Swap Nodes in Pairs，成对儿反转

问题描述：1->2->3->4,假设k=2进行反转，得到2->1->4->3；k=3进行反转，得到3->2->1->4

算法思想：基本操作就是链表反转，将k个元素当作滑动窗口，依次进行反转。

 public class ReverseNodesInKGroup {
     public ListNode reverseKGroup(ListNode head, int k) {
         if (k == 1 || head == null || head.next == null)
             return head;
         ListNode first = head, last = head;
         ListNode preHead = new ListNode(-1);
         preHead.next = head;
         ListNode preGroup = preHead, nextGroup = preHead;
         int count = 1;
         while (last != null)
         {
             if (count != k)
             {
                 last = last.next;
                 count++;
             }
             else
             {
                 nextGroup = last.next;
                 reverseList(first, last);// 节点反转后，first <- ... <-clast
                 preGroup.next = last;// 前面转换过的组连接到新的组，pregrou记录prehead,最后返回prehead
                 preGroup = first;
                 first.next = nextGroup;
                 first = nextGroup;
                 last = nextGroup;
                 count = 1;
             }

         }
         return preHead.next;
     }
     //基本反转操作
     private void reverseList(ListNode head, ListNode tail) {
         ListNode pre = new ListNode(-1), node = head;
         pre.next = head;
         while (pre != tail) {
             ListNode temp = node.next;
             node.next = pre;
             pre = node;
             node = temp;
         }
     }
 }

特例Swap nodes in pairs

问题描述：给一序列，交换每相邻的两个元素，并返回头结点。例如：1-2-3-4   返回序列2-1-4-3

算法思路：除了第一组元素，其他每次交换一对儿元素，要改变四个指针。所以，定义四个指针。其中只有两个指针是不想关，其他依赖这两个指针。

方法一：

 public ListNode swapPairs(ListNode head) {
         if(head == null || head.next == null)
            {
                return head;
            }
         ListNode pPre = new ListNode(0);
         pPre.next = head;
         ListNode p1 = head;
         ListNode p2 = null;
         ListNode pNext = null;
         ListNode temp = null;
         while(p1!= null && p1.next != null)
         {
             p2 = p1.next;
             if(p1 == head)
             {
                 temp = p2;
             }
             pNext = p2.next;
             p2.next = p1;
             p1.next = pNext;
             pPre.next = p2;
             pPre = p1;
             p1 = pNext;
         }
         return temp;

     }

方法二：

public static ListNode swapPairs(ListNode head) {
        ListNode pPrepre = null;  //节点对的前前元素
        ListNode pPre = null;     //节点对的前一个元素，依赖p
        ListNode p = head;        //要移动的节点对的第一个元素
        ListNode pNext = null;    //节点对的第二个元素，依赖p
        while (p != null && p.next != null) {
            pPre = p;
            p = p.next;
            pNext = p.next;
            if (pPre == head) {
                head = p;
            }
            if (pPrepre != null) {
                pPrepre.next = p;
            }
            p.next = pPre;
            pPre.next = pNext;

            pPrepre = pPre;//其他元素都依赖p，但pPrepre不依赖p，所以每次移动pPrepre和p
            p = pNext;
        }
        return head;
    }