LeetCode算法题解 206-反转链表

题目描述

题解：

解法1：递归法
解法2：迭代法
解法3：直接反转元素法
具体的思路看代码注释（如果不理解，跟着模拟一遍就可以了），还有其他的解法直接看LeetCode里面的题解吧。

代码：

/**
 * 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) {// 1 2 3 4 5 => 5 4 3 2 1
        /* 1. 递归解法(8ms & 9.1MB)
        if(head == NULL)
        {
            return NULL;// 如果没有元素，直接返回NULL
        }
        if(head->next == NULL)
        {
            return head;// 如果遇到最后一个节点，直接返回这个节点
        }
        ListNode* newHead = reverseList(head->next);// 将最后一次返回的，也就是最后一个节点，作为新的头节点
        head->next->next = head;// head都属于最后一个节点前面的节点，比如倒数第二个节点，将这个节点的next(也就是后面的节点)的next(后面的后面)指向这个节点，也就实现了反转
        head->next = NULL;// 然后将这个节点的next指向NULL，表示这是此时的最后一个节点
        return newHead;
        */
        
        /*2. 迭代解法(8ms & 9.1MB) 这个算法不太好讲，跟着模拟一遍就ok了
        ListNode* pre = NULL;
        ListNode* cur = head;
        while(cur != NULL)
        {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
        */
            
        /* 3.反转前两个元素法(20ms & 9mb)  这个也跟着模拟一遍即可
        if(head == NULL || head->next == NULL)
        {
            return head;// 如果是没有元素或者只有一个元素，都直接返回
        }
        ListNode* p;
        ListNode* q;// q总是位于p后面
        p = head->next;
        q = head->next->next;
        
        p->next = head;// 先反转前两个元素
        head->next = NULL;
        while(q)
        {
            ListNode* t;// t总是位于q后面
            t = q->next;
            q->next = p;
            p = q;
            q = t;
            
        }
        return p;
        */    
    }
};