reverse-linked-list-ii

每次打链表的题，就像便秘一样难受。
虽然过了,但是感觉还是可以更加优化的。
给输入的无头节点的单链表加上一个头节点，方便我们操作。
我们可以先记录m前一个位置的节点，n节点的后一个节点，从理论上来说这两个节点是必定存在的。
然后我们就可以对[m,n]之间的节点进行操作了，先拷贝一个秩为m的节点作为头节点，将秩为m的节点与n后面的一个节点相连，然后每次取出一个节点，让其指向特定的节点。因为是反向连接的，所以最后终止的时候秩为n的节点必然是头节点。

#include <iostream>
using namespace std;



  struct ListNode {
      int val;
      ListNode *next;
      ListNode(int x) : val(x), next(NULL) {}
  };


ListNode *reverseBetween(ListNode *head, int m, int n) {
       ListNode* hh = new ListNode(-1);
        hh->next = head;
        ListNode* p1 = hh;
        ListNode* p2;
        int t = 1;
        ListNode* p=hh;
        while(t<m){
            p = p->next;
            t++;
        }
        p1 = p;
        p=p->next->next;
        while(t<n){
            p=p->next;
            t++;
        }
        p2 = p;
        ListNode* k = new ListNode(p1->next->val);
        k->next = p2;
        p = p1->next->next;
        while(p!=p2) {
            ListNode* tmp = new ListNode(p->val);
            tmp->next = k;
            k = tmp;
            p = p->next;
        }

        p1->next = k;
        return hh->next;
}

void pf(ListNode* p) {
    while(p) {
        cout<<p->val<<" ";
        p = p->next;
    }
    cout<<endl;
}

ListNode* ini() {
    int n;
    cin>>n;
    ListNode* h=new ListNode(0);
    ListNode* p = h;
    for (int i=0;i<n;i++) {
        int data;
        cin>>data;
        ListNode* tmp = new ListNode(data);
        p->next = tmp;
        p = p->next;
    }
    return h->next;
}


int main() {
    ListNode* h =ini();
    pf(h);
    ListNode* p = reverseBetween(h,2,4);
    pf(p);
}