【LeetCode】【链表】剑指 Offer 24. 反转链表 思路解析和代码

剑指 Offer 24. 反转链表

题目链接

个人思路

思路

个人思路

栈

• 先遍历一遍数组，将所有元素存入栈中
• 从栈中取出元素，构建链表

注意：栈中最后一个元素的next要指向null，否则会构成一个环，因为原本最后一个元素的next是指向倒数第二个元素的（在栈中的位置）

双指针思路（个人错误思路与正确思路对比）

整体思路都是用pre指针标记前面的链表，要让当前元素的next指向前面的链表，并且还不丢失下一个元素

错误思路	错误代码含义	正确思路	正确代码含义
temp = cur	为了备份cur，通过temp连接前面的结点	pnext = cur->next	为了找到下一个节点，使下一个节点不丢失
cur = cur->next	cur后移到下一个节点	cur->next = pre	cur连接前面的节点
temp->next = pre	temp连接前面的节点	pre = cur	pre后移到cur的位置
pre = temp	pre后移到temp的位置	cur = pnext	cur后移到下一个节点

• 错误思路是想声明一个temp节点来备份cur，这样可以用temp的next构造反向链表，不会因为cur的后移而失去当前节点的数据
• 正确思路是为了避免因为cur连接前面的结点而失去下一个节点的数据，因此先保存后一个节点的数据，然后再通过cur连接前面的链表，并通过保存的结点完成cur的后移

个人思路代码

错误思路

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL){
            return NULL;
        }
        if(head->next == NULL){
            return head;
        }
        ListNode *pre = head, *cur = head->next;
        ListNode *ans = NULL;
        while(cur != NULL){
            if(cur->next == NULL){
                ans = cur;
            }
            ListNode *temp = cur;
            cur = cur->next;
            temp->next = pre;
            pre = temp;
        }
        return pre;
    }
};

正确思路

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL){
            return NULL;
        }
        if(head->next == NULL){
            return head;
        }
        ListNode *pre = NULL;
        ListNode *cur = head;
        ListNode *ans = NULL;
        while(cur != NULL){
            ListNode *pNext = cur->next;
            if(cur->next == NULL){
                ans = cur;
            }
            cur->next = pre;
            pre = cur;
            cur = pNext;
        }
        return ans;
    }
};

栈

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL){
            return NULL;
        }
        stack<ListNode*> s;
        ListNode* cur = head;
        while(cur != NULL){
            s.push(cur);
            cur = cur->next;
        }
        ListNode *ans = s.top();
        cur = ans;
        s.pop();
        while(!s.empty()){
            ListNode* temp = s.top();
            s.pop();
            cur->next = temp;
            cur = cur->next;
        }
        cur->next = NULL;//一定要让最后一个元素的next指向NULL，否则会构成环，因为原本的最后一个元素的next是指向倒数第二个的（以栈中的顺序）
        return ans;
    }
};