C语言链表翻转算法（包含递归算法和非递归算法）

C语言链表翻转算法

递归算法

Linklist reverselist_rec(LNode *L, LNode *P)//带头结点递归算法
{
	LNode *N = P;
	if (P->next == NULL)//当访问到最后一个节点时返回
	{
		L->next = P;
		return P;
	}
	P = reverselist_rec(L, P->next);//返回的节点P是当前节点N的后一个节点
	P->next = N;//使返回的节点指向当前节点来实现逐级翻转
	N->next = NULL;//这一步主要是为了链表完全翻转后，原来的第一个节点，也就是现在的最后一个节点的指针域为空，防止处出现链表循环
	return N;
}

非递归算法

第一种：借助栈作为辅助

Linklist reverselist_01(LNode *L)//带头结点非递归算法
{
	typedef struct {  //借助栈来翻转链表
		int data[M];
		int top;
	}Sqstack;
	Sqstack S;
	S.top = -1;
	LNode *P;
	P = L->next;
	while (P != NULL)
	{
		S.data[++S.top] = P->data;
		P = P->next;
	}
	P = L->next;
	while (S.top != -1)
	{
		P->data = S.data[S.top--];
		P = P->next;
	}
	return L;
}

第二种：头插法来翻转链表，把链表节点一个一个用头插法重新插入链表

```c
Linklist reverselist_02(LNode *L)//用头插法来翻转链表
{
	LNode *p = L->next, *r;
	L->next = NULL;
	while (p != NULL)
	{
		r = p->next;
		p->next = L->next;
		L->next = p;
		p = r;
	}
	return L;
}

第三种：王道数据结构书上的，设计三个指针，pre指向第一个节点，p指向中间节点，r指向第三个节点，将p的next指向pre，r指向p后一个节点防止断链，然后三个节点不断往后移，重复操作。个人觉得这种算法并没有太多值得借鉴的地方，从某种意义上讲就是头插法的变形，将链表视作没有头节点的链表，pre视作头指针，这种解法就是头插法。

程序测试（VS2017环境下）

#include<stdio.h>
#include<stdlib.h>
#define M 10
typedef struct LNode {
	int data;
	struct LNode *next;
}LNode, *Linklist;
int output(Linklist L);
Linklist reverselist_rec(LNode *L, LNode *P);
Linklist reverselist_01(LNode *L);
Linklist reverselist_02(LNode *L);
Linklist reverselist_03(LNode *L);
void init_list(Linklist L, int n);
int main()
{
	Linklist L;
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	init_list(L, 5);
	printf("初始链表\n");
	output(L);
	reverselist_rec(L, L->next);
	printf("使用递归算法翻转后\n");
	output(L);
	reverselist_01(L);
	printf("使用非递归算法1再次翻转后\n");
	output(L);
	reverselist_02(L);
	printf("使用非递归算法2再次翻转后\n");
	output(L);
	reverselist_03(L);
	printf("使用非递归算法3再次翻转后\n");
	output(L);
}
Linklist reverselist_rec(LNode *L, LNode *P)//带头结点递归算法
{
	LNode *N = P;
	if (P->next == NULL)//当访问到最后一个节点时返回
	{
		L->next = P;
		return P;
	}
	P = reverselist_rec(L, P->next);//返回的节点P是当前节点N的后一个节点
	P->next = N;//使返回的节点指向当前节点来实现逐级翻转
	N->next = NULL;//这一步主要是为了链表完全翻转后，原来的第一个节点，也就是现在的最后一个节点的指针域为空，防止处出现链表循环
	return N;
}

Linklist reverselist_01(LNode *L)//带头结点非递归算法
{
	typedef struct {  //借助栈来翻转链表
		int data[M];
		int top;
	}Sqstack;
	Sqstack S;
	S.top = -1;
	LNode *P;
	P = L->next;
	while (P != NULL)
	{
		S.data[++S.top] = P->data;
		P = P->next;
	}
	P = L->next;
	while (S.top != -1)
	{
		P->data = S.data[S.top--];
		P = P->next;
	}
	return L;
}
Linklist reverselist_02(LNode *L)//用头插法来翻转链表
{
	LNode *p = L->next, *r;
	L->next = NULL;
	while (p != NULL)
	{
		r = p->next;
		p->next = L->next;
		L->next = p;
		p = r;
	}
	return L;
}
Linklist reverselist_03(LNode *L)
{
	LNode *pre, *p = L->next, *r = p->next;
	p->next = NULL;
	while (r != NULL)
	{
		pre = p;
		p = r;
		r = r->next;
		p->next = pre;
	}
	L->next = p;
	return L;
}
int output(Linklist L)
{
	Linklist S = L->next;
	while (S != NULL)
	{
		printf("%d ", S->data);
		S = S->next;

	}
	printf("\n");
	return 0;
}
void init_list(Linklist L, int n)//头插法初始化一个链表
{
	LNode *S = L;
	for (int i = 0; i < n; i++)
	{
		S = (LNode*)malloc(sizeof(LNode));
		S->data = i+1;
		S->next = L->next;
		L->next = S;
	}
}

运行结果