【剑指offer】3.反转链表

 

总目录：

 

算法之旅导航目录

 

 

1.问题描述
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。
数据范围： 0<=≤n≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n) 。

如当输入链表{1,2,3}时，

经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。
以上转换过程如下图所示：

 

2.题目解析：

注意题干，

1要求空间复杂度为O(1),即过程中不允许使用导致内存增加的操作；

2.要求时间复杂度为O(n),

想到的方法有

1简单地迭代，逐个由从前向后指变为从后向前指，需要注意边界条件；

2.递归，最后一个非空节点即为返回值，往回迭代的过程中改变指向，注意最开始的head最终要指向null;

3.不能用栈，会造成空间复杂度上升，从而不符合=O(1)的要求;

 

3.cpp代码

简单迭代法

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
  public:
    ListNode* ReverseList(ListNode* pHead) {
        if (pHead == NULL) {
            return pHead;
        }

        ListNode* pPre = NULL;
        ListNode* pNext = NULL;
        while (pHead != NULL) {

            //获取next
            pNext = pHead->next;

            //翻转指向
            pHead->next = pPre;

            //更新指针
            if (pNext == NULL) {
                return pHead;
            }
            pPre = pHead;
            pHead = pNext;
        }

        return pHead;
    }
};

递归法

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
  public:
    void recurve(ListNode* cur, ListNode* next, ListNode*& newHead) {
        //终止条件
        if (next == NULL) {
            newHead = cur;//cherry pick
            return;
        }

        //递归调用
        recurve(next, next->next, newHead);

        //本级任务
        //下一个非空节点指向当前节点
        cur->next->next = cur;
        cur->next=NULL;
    }


    ListNode* ReverseList(ListNode* pHead) {
        //防止输入为空
        if (pHead == NULL) {
            return pHead;
        }

        //去接收最终的head
        ListNode* newHead = NULL;
        recurve(pHead, pHead->next, newHead);

        return newHead;
    }
};

 虽然但是，用栈的方法，参考一下

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
  public:
    ListNode* ReverseList(ListNode* pHead) {
        //存入栈中
        stack<ListNode*> sp;
        while (pHead != NULL) {
            sp.push(pHead);
            pHead = pHead->next;
        }

        if (sp.empty()) {
            return NULL;
        }

        //取head
        ListNode* cur=sp.top();
        pHead=cur;//维护返回值
        sp.pop();

        //依次翻转指向
        while (!sp.empty()) {
            ListNode* temp = sp.top();
            sp.pop();
            cur->next=temp;
            cur=temp;
        }

        //最后一个非空节点，不要让其维持原指向
        cur->next=NULL;

        return pHead;
    }
};