链表反转

最新推荐文章于 2022-03-07 15:23:42 发布

一的三次方

最新推荐文章于 2022-03-07 15:23:42 发布

阅读量530

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/mike_learns_to_rock/article/details/46573131

版权

leetcode 专栏收录该内容

69 篇文章 0 订阅

订阅专栏

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

链表尤其是单向链表是一个比较简答的问题，一般容易出错的点是对结尾处NULL的考虑不到位。

比如 (1) 此时指针已经为空，然而还要求其next指针。一般是在用循环求解这一类问题时，忽略边界条件的限制，导致ListNode* p==NULL;的时候仍然写出p->next;

(2) 重构链表的时候，没有给最后的结点next赋值为NULL;一般创建的时候不会出现这种问题，因为创建new的时候默认的next值就是NULL；

一般在修改原链表的时候，忽略这一点会带来不小的麻烦。

看下面这非常简单的例子。

1，链表翻转

（1）翻转自然想到是借助一个stack来实现，这里用vector来构建一个stack；

ListNode* reverseList(ListNode* head) {
        if(!head) return NULL;
        vector<ListNode*> stack;
        stack.push_back(head);
        while(stack.back()->next!=NULL){
            stack.push_back(stack.back()->next);
        }
        ListNode* p=stack.back();
        stack.pop_back();
        ListNode* pHead=p;
        while(stack.size()>0){
            p->next=stack.back();
            p=stack.back();
            stack.pop_back();
        }
        p->next=NULL;//不要忘记赋值。
        return pHead;
    }

优点是：思路清晰，不容易出错。

缺点是：第一次访问链表，然后访问数组，相当于访问了两次这个链表，时间有点多；

空间复杂度为O(n);

（2）考虑3个指针实现。只需要一次遍历链表即可输出。

ListNode* reverseList(ListNode* head) {
        if(!head) return NULL;
        if(head->next==NULL) return head;
        ListNode* p1,*p2,*p3;
        for(p1=head,p2=head->next,p3=head->next->next;p1&&p2&&p3;){
            if(p1==head) p1->next=NULL;//这个不要忘记了
            p2->next=p1;
            p1=p2,p2=p3,p3=p3->next;
        }
        if(p1==head) p1->next=NULL;//这个不要忘记了
        p2->next=p1;
        return p2;
    }

关于为什么需要第三个指针，p2->next=p1;之后，我们无法找到原有的p2下一个结点了。

Reverse Linked List II

For example:
Given 1->2->3->4->5->NULL, m = 2 and n = 4,

return 1->4->3->2->5->NULL.

Note:
Given m, n satisfy the following condition:
1 ≤ m ≤ n ≤ length of list.

这题要求比较细心就好。一次ac。

ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(!head) return NULL;
        if(m==n) return head;
        ListNode dummy(-1);
        dummy.next=head;
        ListNode *p1=&dummy,*p2=&dummy;
        for(int i=0;i<m-1;i++){//p1是m的前一个结点
            p1=p1->next;
        }
        p2=p1->next;
        for(int i=0;i<n-m;i++){//p2在n位置上
            p2=p2->next;
        }
        ListNode* cur=p1->next;
        p1->next=p2;//边界结点大转向
        ListNode *prev=cur;
        cur=cur->next;
        ListNode *post=cur->next;//最坏post=NULL;
        prev->next=p2->next;//边界结点大转向
        cur->next=prev;
        while(post!=NULL&&cur!=p2){
            prev=cur;
            cur=post;
            post=post->next;
            cur->next=prev;
        }
        return dummy.next;
 
    }