链表系列文章(三)

上一篇讨论了链表相关的几个有趣的问题，这一篇主要讨论与反转链表有关的问题

基本数据结构：

struct ListNode {
    int var;
    ListNode *next;
    ListNode( int v = 0 ) : var(v), next(NULL) { }
};

1.  反转链表

方法一：堆栈法，利用栈后进先出的特性，将链表节点依次入栈，然后弹出并修改next指针

时间复杂度O(n)，空间复杂度O(n)

ListNode *reverseList(ListNode *head) {
    if(!head || !head->next) return head;
    ListNode newhead(-1), *h = &newhead;
    std::vector<ListNode *> s;
    for( ; head; head = head->next ) s.push_back(head);
    while(!s.empty()) { h->next = s.back(); s.pop_back(); h = h->next; }
    h->next = NULL;
    return newhead.next;
};

方法二：头插法，创建一个新的头节点，然后遍历链表节点，将每个节点依次插入到头节点后

时间复杂度O(n)，空间复杂度O(1)

ListNode *reverseList(ListNode *head) {
    if(!head || !head->next) return head;
    ListNode newhead(-1), *h = &newhead, *temp = NULL;
    while(head) {
        temp = head->next;
        head->next = h->next;
        h->next = head;
        head = temp;
    }
    return newhead.next;
};

方法三：前插法，把链表分为两部分，依次把后一部分的节点前插到前一部分

时间复杂度O(n)，空间复杂度O(1)

ListNode *reverseList(ListNode *head) {
    if(!head || !head->next) return head;
    ListNode *prev = head, *curr = prev->next, *next = NULL;
    prev->next = NULL;
    while(curr) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
};

2.  反转链表的[m, n]区间的节点

和反转链表的区别是，我们必须保存反转后的尾指针，使其指向第n+1个节点

方法一：堆栈法，相比上个问题，只需保存一下第n+1个节点地址即可，不再赘述

方法二：头插法，时间复杂度O(n)，空间复杂度O(1)

ListNode *reverseList( ListNode *list, int m, int n ) { 
    ListNode *head = new ListNode();
    ListNode *phead = head;
    ListNode *curr, *prev;
    phead->next = list;
    n -= m;//需要反转的次数
    while( --m ) { phead = phead->next; } //phead->next指向第m个节点
    prev = phead->next;//prev指向反转区间的尾部
    curr = prev->next;//指向反转区间的头部
    while( n-- ) { 
        prev->next = curr->next;//这里的prev->next其实就是尾指针!!!
        curr->next = phead->next;
        phead->next = curr;//头插法
        curr = prev->next;  
    }   
    return head->next;
}   

3. 给定两个指针begin和end，反转begin->...->end之间的节点，返回反转后的倒数第一个节点指针

方法参考 2.  反转链表的[m, n]区间的节点

ListNode* reverseList(ListNode *prev, ListNode *begin, ListNode *end) {
    ListNode *end_next = end->next;
    for (ListNode *p = begin, *cur = p->next, *next = cur->next;
        cur != end_next;
        p = cur, cur = next, next = next ? next->next : NULL) {
        cur->next = p;
    }
    begin->next = end_next;//这里的begin->next其实就是尾指针!!!
    prev->next = end;
    return begin;
}

4. 小结

反转链表本身比较简单，但是当要区间反转时，一定要牢记，不能忘了尾指针！！！

由于本人水平有限，文中难免有不当和错误之处，欢迎大家批评指正，愿共同进步！！！