LeetCode每日精进：206.反转链表

题目链接：206.反转链表

题目描述：

        给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

• 链表中节点的数目范围是 [0, 5000]
• -5000 <= Node.val <= 5000

思路一：创建新链表，遍历原链表，逐个头插

    ListNode* pcur = head;
    ListNode* newHead = NULL;
    ListNode* newTail = NULL;

        定义pcur遍历原链表，newHead指向新链表的头结点，newTail指向新链表的尾结点。

        if (newHead == NULL)
        {
            newHead = newTail = pcur;
        }

        新链表为空时，让newTail和newHead都指向pcur。

        else{
            pcur->next = newHead;
            newHead = pcur;
        }

        新链表不为空时，让pcur的next指针指向新链表的头结点，并让头结点前移到pcur。

    if (newTail)
    {
        newTail->next = NULL;
    }

        最后，将尾结点的next指针置空，避免链表成环。

完整代码：

 typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {
    ListNode* pcur = head;
    ListNode* newHead = NULL;
    ListNode* newTail = NULL;
    while(pcur)
    {
        ListNode* next = pcur->next;
        if (newHead == NULL)
        {
            newHead = newTail = pcur;
        }
        else{
            pcur->next = newHead;
            newHead = pcur;
        }
        pcur = next;
    }
    if (newTail)
    {
        newTail->next = NULL;
    }
    return newHead;
}

        时间复杂度O(n) 

思路二：创建三个指针，改变指针指向

    ListNode* n1 = NULL;
    ListNode* n2 = head;
    ListNode* n3 = head->next;

 

        定义n1初始指向空，n2指向头结点，n3指向头结点的下一个结点。

        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if (n3)
            n3 = n3->next;

        在调整指针指向的过程中，让n2的next指针指向n1，n1移向n2，n2移向n3，n3移向自己的下个结点，若此时n3指向空，n3不移动。

循环操作：

        可以看出在循环中，n1，n2用来改变结点的指向，n3用来占n2的下一个结点的位置，当n2为空时跳出循环，此时n1为反转后的链表头部，返回n1即可。

完整代码：

 typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {
    if (head == NULL)
    {
        return head;
    }
    ListNode* n1 = NULL;
    ListNode* n2 = head;
    ListNode* n3 = head->next;
    while(n2)
    {
        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if (n3)
            n3 = n3->next;
    }
    return n1;
}

        时间复杂度O(n)