算法 反转链表

前言

题目链接

---

一、迭代法1

1.1

链表的原始状态如下所示：

1.2

首先，定义三个指针变量 prev，curr 和 next。
刚开始，prev 指向 NULL； curr 指向第一个节点，next 指向第二个节点。

第一阶段迭代，让 curr 节点的 next指向 prev 节点。
此时，节点1的 next 指向 NULL。

第二阶段迭代， prev，curr 和 next 向后迭代。
此时 prev 指向节点1，curr 指向节点2，next 指向节点3。
接着，继续让 curr 节点的 next 指向 prev 节点。
此时，节点2的 next 指向 节点1。

最终代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){
    struct ListNode *prev = NULL, *curr = NULL, *next = NULL;

    if (head == NULL) return NULL;

    curr = head;

    while(curr)
    {
        next = curr->next;

        curr->next = prev;

        prev = curr;
        curr = next;
    }

    return prev;
}

---

二、迭代法2

该方法使用“串葫芦”的方法。图解如下

2.1

初始状态如下：

---

2.2

首先，定义三个指针变量 list1_curr，list1_next和 list2_head。
刚开始，list1_curr 和 list1_next 属于原始的链表，list2_head 属于新串的链表。

第一阶段迭代，让 list1_curr 节点的 next指向 list2_head 节点。
此时，list1_curr 节点成为了新串链表的头节点。

之后，进行状态更替：
list1_curr 赋值给 list2_head ；
list1_next 赋值给 list1_curr ；
list1_curr 的 nexti 节点成为新的 list1_next 。

---

2.3

第二阶段迭代，重复第一阶段的操作。
此时，新串又得到了最新的链表头，而且新串链表与原有链表是翻转的。

---

最终代码如下：

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode *list1_curr = NULL, *list1_next = NULL, *list2_head = NULL;

    if (head == NULL) return NULL;

    list1_curr = head;

    while(list1_curr)
    {
        list1_next = list1_curr->next;

        list1_curr->next = list2_head;

        list2_head = list1_curr;
        list1_curr = list1_next;
    }

    return list2_head;
}

---

三、递归法

图解如下，不再赘述。

3.1

第一阶段

---

3.2

第二阶段

---

3.3

最终代码如下：

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode *curr = NULL, *next = NULL, *ret = NULL;

    if ( !head || !head->next) return head;

    curr = head;
    next = curr->next;

    ret = reverseList(next);

    next->next = curr;
    curr->next = NULL;
    
    return ret;
}

---