单链表的反转（非递归）

问题：输入一个链表的头节点，反转该链表，并返回反转后链表的头节点。

分析：
（1）首先，注意一个概念，头节点，头节点中并没有真正的链表数据，而且头节点的存在仅仅是为了方便计算，所以反转链表是指”反转除了头节点之外的链表中所有的节点“，头节点是永远位于链表的头部的，但头节点一般不能称为链表的第一个节点，链表的第一个节点是指紧跟着头节点之后的那个节点，第一个节点有时也成为“开始节点”。
（2）一般我们创建的单链表有两种，第一种：有头节点的单链表；第二种：没有头节点的单链表；本题由题目可知，该单链表是带头节点的单链表。

实现方法：
方法1：将单链表储存为数组，然后按照数组的索引逆序进行反转。(浪费空间，一般不用)
方法2：使用3个指针遍历单链表，逐个节点进行反转(能做到“原地反转”)。(较常用)
方法3：如果不要求“原地”反转，可以通过正向遍历原链表，在头指针和头节点位置不变的情况下，采用头插法建立一个新的单向链表，即可实现原链表的逆序。即从第2个节点(即头节点之后的第二个节点)到第N个节点，依次逐节点插入到头节点之后即可。
方法4: 递归

注意点：
（1）对方法2，有头节点的单链表和没有头节点的单链表，处理方式稍有不同，具体见代码；
（2）对方法3，如果反转的是“不带头节点的单链表”，那么和上述也稍有不同，应该从第3个节点到第N个节点，依次逐节点插入到第一个节点之后即可，依次插入完成后，第二个节点此时是最后一个节点，最后再将第一个节点挪到新表的表尾，完成不带头节点的单链表的反转；

#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    int data;
    struct node *next;
} NODE;


// 尾插法创建单链表(带头节点)
NODE *createEnd(int arr[], int len)
{
    NODE *head = (NODE *)malloc(sizeof(NODE)); // 生成头节点
    head->next = NULL;
    NODE *end = head;  // 尾指针初始化

    for (int i = 0; i < len; i++) {

        NODE *p = (NODE *)malloc(sizeof(NODE)); // 为每个数组元素建立一个节点
        p->data = arr[i];
        end->next = p;  // 将节点p插入到终端节点之后
        end = p;
    }

    end->next = NULL;  // 单链表建立完毕，将终端节点的指针域置空

    return head;
}



// 方法2:
// 适用于：(有头节点的)单链表反转，头指针指向头节点(注意：有头节点时，链表的第一个节点是紧跟头节点后的那个节点)
NODE *reverse_1(NODE *head)
{
    NODE *reverse_first = NULL; // 反转后链表的第一个节点
    NODE *p_now = head->next; // 让当前节点指向第一个节点（不是头指针指向的节点，而是头节点之后的那个节点）
    if（head == NULL || p_now == NULL） return head;

    NODE *p_prev = NULL; // 初始化为NULL；第一次使用时，可作为反转后链表的最后一个节点的next的指向，即NULL


    while (p_now != NULL)
    {
        NODE *p_next = p_now->next;
        if (p_next == NULL)
            reverse_first = p_now;
        p_now->next = p_prev;
        p_prev = p_now;
        p_now = p_next;

    }

    head->next = reverse_first;

    return head;

}


// 方法2:
// 适用于：(没有头节点的)单链表反转，头指针指向链表的第一个节点
NODE *reverse_2(NODE *head)
{
    NODE *reverse_first = NULL; // 反转后链表的第一个节点，先初始化为NULL
    NODE *p_now = head; // 让当前节点指向第一个节点，即头指针指向的节点（注意：此时是没有头节点的单链表）
    NODE *p_prev = NULL; // 初始化为NULL；第一次使用时，可作为反转后链表的最后一个节点的next的指向，即NULL


    while (p_now != NULL)
    {
        NODE *p_next = p_now->next;
        if (p_next == NULL)
            reverse_first = p_now;
        p_now->next = p_prev;
        p_prev = p_now;
        p_now = p_next;

    }
    head = reverse_first; // 没有头节点，头指针指向的是第一个节点；
    return head;
}




// 方法3:
// 适用于:(有头节点的)单链表，实现链表反转
NODE *reverse_3(NODE *head)
{

    NODE *first = head->next;
    NODE *second = first->next;
    if (head == NULL || first == NULL) return head;

    first->next = NULL; // 在原链表中的first节点处，断开连接；

    while (second != NULL)
    {
        NODE *third = second->next; // 先保存second后的那个节点
        second->next = first;
        first = second;
        second = third;

    }

    head->next = first; // 将链表的头节点指向first

    return head;

}



// 方法3:
// 适用于:(没有头节点的）单链表，实现反转链表
NODE *reverse_4(NODE *head)
{
    if (head == NULL) return head;

    NODE *first = head->next;

    while (first->next != NULL) {
        NODE *second = first->next; //  先保存first后的那个节点
        first->next = second->next;
        second->next = head->next;
        head->next = second;
    }
    // 经过上述while循环后，原链表的第二个节点此时位于链表的末尾；注意：此时链表的第一个节点仍是原链表的第一个节点；

    first->next=head; // 让经过循环后的链表的最后一个节点，指向第一个节点(也即原链表的第一个节点)，恰好构成一个环；
    head=first->next->next; // 新head变为原head的next
    first->next->next=NULL; // 断掉环；此时，原链表的第一个节点是反转后链表的尾节点；

    return head;

}


// 单链表打印
void print(NODE *head)
{
    if (head == NULL) return;

    NODE *p = head->next;
    while (p != NULL) {
        printf("%d\n", p->data);
        p = p->next;
    }
}

int main(void)
{
    int arr[] = {1,2,3,4,5,6,7};
    int len = sizeof(arr)/sizeof(int);

    NODE *head = createEnd(arr, len);

    print(head);

    printf("-----------\n");
    NODE *p_reverse = reverse_1(head); // 有头节点的单链表的反转
    print(p_reverse);


    return 0;
}