链表的反转

1.单链表的反转

#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef int ElemType;
typedef struct LNode* LinkList;
typedef struct LNode{
	ElemType data;
	LinkList next;
}LNode;
//初始化
void InitList(LinkList &L){
	L = new LNode;
	L->next = NULL;
	return;
}
//插入
void InsertList(LinkList &L, ElemType e){
	if (!L){
		InitList(L);
		L->data = e;
		return;
	}
	else{
		InsertList(L->next, e);
	}
}
//反转
void ReverseList(LinkList &L){
	LinkList q = NULL, p;//p是当前节点；q是p的前驱
	while (L){
		p = L;
		L = L->next;
		p->next = q;
		q = p;
	}
	L = p;//这样p永远是表头
	return;
}
//输出
void OutputList(LinkList L){
	if (!L){ printf("空\n"); return; }
	while (L){
		printf("%d ", L->data);
		L = L->next;
	}
	printf("\n");
	return;
}
int main(){
	LinkList L = NULL;
	int n;
	ElemType t;
	scanf("%d", &n);
	while (n--){
		scanf("%d", &t);
		InsertList(L, t);
	}
	OutputList(L);
	ReverseList(L);
	OutputList(L);
	return 0;
}

1.0结构体

typedef int ElemType;
typedef struct LNode* LinkList;
typedef struct LNode{
	ElemType data;
	LinkList next;
}LNode;

1.1初始化

void InitList(LinkList &L){
	L = new LNode;
	L->next = NULL;
	return;
}

1.2插入

void InsertList(LinkList &L, ElemType e){
	if (!L){
		InitList(L);
		L->data = e;
		return;
	}
	else{
		InsertList(L->next, e);
	}
}

1.3反转

void ReverseList(LinkList &L){
	LinkList q = NULL, p;//p是当前节点；q是p的前驱
	while (L){
		p = L;
		L = L->next;
		p->next = q;
		q = p;
	}
	L = p;//这样p永远是表头
	return;
}

1.4输出

void OutputList(LinkList L){
	if (!L){ printf("空\n"); return; }
	while (L){
		printf("%d ", L->data);
		L = L->next;
	}
	printf("\n");
	return;
}

2.双向链表

#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef int ElemType;
typedef struct LNode *LinkList;
typedef struct LNode{
	ElemType data;
	LinkList next, previous;
}LNode;
//初始化
void InitList(LinkList &L){
	L = new LNode;
	L->previous = NULL;
	L->next = NULL;
	return;
}
//插入
void InsertList(LinkList &L, ElemType e){
	if (!L){
		InitList(L);
		L->data = e;
	}
	else{
		InsertList(L->next, e);
		L->next->previous = L;
	}
}
//翻转
void ReverseList(LinkList &L){
	if (!L){return; }
	LinkList p, q = NULL, t;//p代表当前点，q是p的前驱，t是p的后导
	while (L){
		p = L;
		L = L->next;
		t = L;
		p->previous = t;
		p->next = q;
		q = p;
	}
	L = p;//L已经是NULL,p是一开始的尾节点，现在是头结点
	return;
}
//输出
void OutputList(LinkList L){
	if (!L){ printf("空\n"); return; }
	while (L){
		printf("%d ", L->data);
		L = L->next;
	}
	printf("\n");
	return;
}
int main(){
	int n;
	printf("表长：");
	scanf("%d", &n);
	LinkList L=NULL, f = NULL;
	ElemType e;
	while (n--&&n>=0){
		scanf("%d", &e);
		InsertList(L, e);
	}
	OutputList(L);
	ReverseList(L);
	printf("翻转：");
	OutputList(L);
	system("pause");
	return 0;
}

2.0结构体

typedef int ElemType;
typedef struct LNode *LinkList;
typedef struct LNode{
	ElemType data;
	LinkList next, previous;
}LNode;

2.1初始化

void InitList(LinkList &L){
	L = new LNode;
	L->previous = NULL;
	L->next = NULL;
	return;
}

2.2插入

利用了初始化，遇空树则初始化
注意递归返回上一层函数时，要挂接L->next的前驱，因为在初始化并赋值L->next的过程中，它的previous是指向NULL而不是L的

void InsertList(LinkList &L, ElemType e){
	if (!L){
		InitList(L);
		L->data = e;
	}
	else{
		InsertList(L->next, e);
		L->next->previous = L;
	}
}

2.3反转

void ReverseList(LinkList &L){
	if (!L){return; }
	LinkList p, q = NULL, t;//p代表当前点，q是p的前驱，t是p的后导
	while (L){
		p = L;
		L = L->next;
		t = L;
		p->previous = t;
		p->next = q;
		q = p;
	}
	L = p;//L已经是NULL,p是一开始的尾节点，现在是头结点
	return;
}

2.4输出

void OutputList(LinkList L){
	if (!L){ printf("空\n"); return; }
	while (L){
		printf("%d ", L->data);
		L = L->next;
	}
	printf("\n");
	return;
}