（单链表）单链表的整体逆序和局部逆序

• 一：用数组存储单链表的值，然后重新逆序赋值，效率较低。
• 二：利用三个指针，在原来的基础上进行逆序。这种方法比较实用，效率也高。
• 三：从第2个节点到第N个节点，依次逐节点插入到第1个节点(head节点)之后，最后将第一个节点挪到新表的表尾。需要新建一个链表，这种方法和第二种差不多。
• 这里我就写出第二种方法，比较实用。

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
ListNode *ReverseList(ListNode *head){
    ListNode *pre, *cur, *net;//前驱，中间，后继节点。
    pre = head;
    cur = pre->next;
    while (cur){
        net = cur->next;
        cur->next = pre;
        pre = cur;
        cur = net;
    }
    //这里翻转完成之后起初的头结点就是尾节点了。所以
    head->next = NULL;
    *head = p1;
    return head;
}

给定链接列表，每次颠倒链表k的节点并返回其修改的列表。

如果节点的数量不是k的倍数，则最后的左出节点应该保持原样。

您不能更改节点中的值，只有节点本身可能会更改。

只允许常量存储器。

例如，
给定这个链表：1-> 2-> 3-> 4-> 5

对于k = 2，您应该返回：2-> 1-> 4-> 3-> 5

对于k = 3，您应该返回：3-> 2-> 1-> 4-> 5

• 　　解题思路：这里实用了常量数组存储链表的值，然后进行局部链表的翻转，利用reverse函数进行翻转。
• 　　代码

  /**
   * Definition for singly-linked list.
   * struct ListNode {
   *     int val;
   *     ListNode *next;
   *     ListNode(int x) : val(x), next(NULL) {}
   * };
   */
  class Solution {
  public:
      ListNode *reverseKGroup(ListNode *head, int k) {
          if (!head)
              return head;
          if (k == 1)
              return head;
          vector<int> res;
          ListNode *temp = head;
          ListNode *newhead = head;
          while (temp){
              res.push_back(temp->val);
              temp = temp->next;
          }
  
          for (int i=0; i+k<=res.size(); i+=k){
              reverse(res.begin()+i, res.begin()+i+k);
          }
  
          for (int i=0; i<res.size(); i++){
              newhead->val = res[i];
              newhead = newhead->next;
          }
          //delete temp;
          return head;
      }
  };