将单链表翻转的两种方法

单链表翻转很容易理解，例如：

输入： NODE1->NODE2->NODE3->NODE4->NODE5->NULL

输出： NODE5->NODE4->NODE3->NODE2->NODE1->NULL

那么，定义单链表如下： （为简单起见，将data字段定义为int, 当然实际应用中data很可能是一个复杂的结构体）

typedef struct list_s {
        int data;
        struct list_s *next;
} list_t;

如何将单链表翻转，有如下两种方法。

1. 使用N个辅助存储空间aux[]，N为单链表中所有结点的个数。将所有结点的地址反向存入aux[]中，然后根据aux[]重新生成一个单链表。
2. 只使用2个辅助存储空间，从头到尾遍历单链表并翻转。

其中，方法1使用了较多的辅助存储空间，但实现起来很简单，借助了栈（stack）的思想。 跟方法1比起来，方法2的时间效率和空间效率都要更胜一筹，不过实现起来难度稍大一点。

方法1的代码实现如下：

o foo1.c

static int get_length(list_t *head)
{
        int len = 0;
        for (list_t *p = head; p != NULL; p = p->next)
                len++;
        return len;
}

void reverse_singly_linked_list(list_t **head)
{
        if (*head == NULL)
                return;

        int len = get_length(*head);
        if (len < 2)
                return;

        list_t **aux = (list_t **)malloc(sizeof (list_t *) * len);
        if (aux == NULL) /* error */
                return;

        /* save addr of per node to aux[] */
        int index = 0;
        for (list_t *p = *head; p != NULL; p = p->next) {
                aux[len-1-index] = p;
                index++;
        }

        /* rebuild the singly linked list by walking aux[] */
        *head = aux[0];
        for (int i = 0; i < len-1; i++)
                aux[i]->next = aux[i+1];
        aux[len-1]->next = NULL;

        free(aux);
}

方法2的代码实现如下：

o foo2.c

void reverse_singly_linked_list(list_t **head)
{
        list_t *newhead = NULL;
        list_t *this = *head;
        list_t *prev = NULL;

        while (this != NULL) {
                /*
                 * If this->next is NULL, this is the tail node, which should
                 * be the new head
                 */
                if (this->next == NULL)
                        newhead = this;

                /*
                 * ListIn:  prevNode -> thisNode -> nextNode
                 * ListOut: prevNode <- thisNode <- nextNode
                 *          1. thisNode->next = prevNode;
                 *          2.       prevNode = thisNode;
                 *          3.       thisNode = thisNode->next;
                 */
                list_t *next = this->next; /* a. save the next */
                this->next = prev;         /* b. reverse */
                prev = this;               /* c. move prev forward */
                this = next;               /* d. move this forward */
        }

        *head = newhead;
}

用meld diff foo1.c foo2.c截图如下：

完整的C代码点这里

最后，对单链表翻转函数做单元测试需要考虑三种情况：

• 输入的单链表头结点指针为NULL
• 输入的单链表只有一个结点
• 输入的单链表包含多个结点