• 题目一：将单链表翻转。
• 思路：有三种方式。
  • 一：用数组存储单链表的值，然后重新逆序赋值，效率较低。
  • 二：利用三个指针，在原来的基础上进行逆序。这种方法比较实用，效率也高。
  • 三：从第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;
        }
    };

     

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