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

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

     

• 问题三：

  将链接列表从位置m反转到n。 做它在就地和一次通过。
  
  例如：
  给定1-> 2-> 3-> 4-> 5-> NULL，m = 2和n = 4，
  
  return1-> 4-> 3-> 2-> 5-> NULL。
  
  注意：
  给定m，n满足以下条件：
  1≤m≤n≤列表长度。

   

  • 　　解题思路：这个题目也是局部进行链表的翻转，可以使用数组进行存储翻转，但是效率比较低。这个题目纯粹的是考察链表的基本功问题。我们只要将指定区间里面的部分进行翻转（和翻转整个链表一样），设置三个指针，我们这里讲指定范围内最后面的节点依次的往前面移动，这样就实现了联煸的翻转。
    
    
  • 　　代码：

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
    class Solution {
    public:
        ListNode *reverseBetween(ListNode *head, int m, int n) {
            //在指定的范围之内，将链表末端的节点依次插入到前面，实现翻转。
            if (head == NULL)
                return head;
            ListNode *dummy = new ListNode(0);//新生成一个新链表节点，作为空的头结点
            dummy->next = head;
            ListNode *pre = dummy;
            for (int i=1; i<m; i++) {
                pre = pre->next;
            }
            ListNode *cur = pre->next;
            ListNode *net = cur->next;
            //翻转次数为两次，依次将后面的元素调取到指定位置前面，指定三个指针来进行操作即可
            //①：1 2 3 4 5 -> 1 3 2 4 5  将3调到2的前面
            //②：1 3 2 4 5 -> 1 4 3 2 5  将4调到3的前面
            for (int i=0; i<n-m; i++) {//调取次数n-m
                cur->next = net->next;
                net->next = pre->next;
                pre->next = net;
                net = cur->next;
            }
            return dummy->next;
        }
    };