1. 双向链表
1.1 结构与初始化
双向链表也称双链表，每个数据结点都有两个指针，分别指向直接前驱和直接后继。所以从双向链表的任何结点开始都可以方便的找到他的前驱和后继。
双向链表的每个结点如图所示：
双向链表的每个结点.png
双向链表由N个此类结点构成：
双向链表由N个此类结点构成.png
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define NOT_FOUND -1
/* ElemType类型根据实际情况而定，这里假设为int */
typedef int ElemType;
/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Status;
/*线性结构使用顺序表的方式存储*/
//链表结构设计
typedef struct Node {
struct Node *prior;
ElemType data;
struct Node *next;
} Node, *LinkList;
Status InitList(LinkList *L)
{
//产生头结点，并使用L指向此头结点
*L = (LinkList)malloc(sizeof(Node));
//存储空间分配失败
if (*L == NULL) return ERROR;
//将头结点的指针域置空
(*L)->prior = NULL;
(*L)->next = NULL;
return OK;
}
1.2 遍历
Status ListTraverse(LinkList L)
{
if (L == NULL) return ERROR; // 空表
LinkList p = L->next; // 跳过头结点
while (p) {
printf("%d ",p->data);
p = p->next;
}
printf("\n");
return OK;
}
1.3 插入
思路：
1、首先找到插入结点的位置。
2、是不是在链表尾部（这个就直接看代码就好了）
3、temp的next指向p的next
4、p的next的prior指向temp
5、p的next指向temp
6、temp的prior指向p
如下图所示：
插入.png
Status ListInsert(LinkList *L, int loc, ElemType elem)
{
if (*L == NULL) return ERROR; // 空表
LinkList p, q;
p = *L;
int i = 1;
for (; p && i < loc; p = p->next, i++); // 找到idx位置
if(!p || i > loc) return ERROR; // 第idx个元素不存在
q = (LinkList)malloc(sizeof(Node));
if (!q) return ERROR; // 没创建出来报错
q->data = elem;
q->next = p->next; // q的后继指向p的后继，p-next可能为NULL，q->next也不用显式赋值NULL
p->next = q; // p的后继指向q
if (q->next) q->next->prior = q; // q的后继的前驱指向q，最后可能为NULL
q->prior = p; // q的前驱指向p
return OK;
}
1.4 删除
老规矩--思路：
1、找到要删除位置的前一个
2、p的next指向要删除结点的next
3、删除结点的next的prior指向p
4、看下面的图（已经很生动了。。）
删除.png
找到被删除节点，让前后牵手就行了。
Status ListDeleteLoc(LinkList *L, int loc, ElemType *elem)
{
if (*L == NULL) return ERROR; // 空表
LinkList p = (*L)->next;
int i = 1;
for (; p && i < loc; p = p->next, i++); // 找到idx位置
if(!p || i > loc) return ERROR; // 第idx个元素不存在
p->prior->next = p->next; // p的前驱的后继指向p的后继
if (p->next) p->next->prior = p->prior; // p的后继的前驱指向p的前驱，最后可能为NULL
*elem = p->data;
free(p); // 释放被删除节点
return OK;
}
1.5 删除指定元素
Status ListDeleteElem(LinkList *L, ElemType elem)
{
if (*L == NULL) return ERROR; // 空表
LinkList p = (*L)->next;
while (p && p->data != elem) p = p->next; // 找到对应元素
if(!p) return ERROR; // 元素elem不存在
p->prior->next = p->next; // 将p的前驱指向p的后继
if (p->next) p->next->prior = p->prior; // 将p的后继指向p的前驱，最后可能为NULL
free(p); // 释放被删除节点
return OK;
}
1.6 更新指定位置
Status ListUpdateElem(LinkList L, int loc, ElemType elem)
{
if (L == NULL) return ERROR; // 空表
LinkList p = L->next;
int i = 1;
for (; p && i < loc; p = p->next, i++); // 找到idx位置
if(!p || i > loc) return ERROR; // 第idx个元素不存在
p->data = elem;
return OK;
}
2.双向循环链表
2.1 结构与初始化
一个空的双向循环链表如下：
一个空的双向循环链表.png
正常的双向循环链表：
正常的双向循环链表.png
双向循环链表的创建实际就是双向链表的尾节点后驱指向头结点，头结点前驱指向尾节点，最终形成一个环。
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define NOT_FOUND -1
/* ElemType类型根据实际情况而定，这里假设为int */
typedef int ElemType;
/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Status;
/*线性结构使用顺序表的方式存储*/
//链表结构设计
typedef struct Node {
struct Node *prior;
ElemType data;
struct Node *next;
} Node, *LinkList;
Status InitList(LinkList *L, ElemType elem)
{
//产生头结点，并使用L指向此头结点
*L = (LinkList)malloc(sizeof(Node));
//存储空间分配失败
if (*L == NULL) return ERROR;
//将头结点的指针指向自己
(*L)->prior = *L;
(*L)->next = *L;
(*L)->data = elem;
return OK;
}
依次输入创建双向循环链表
Status CreateList2(LinkList *L) {
ElemType elem;
LinkList tail = NULL;
while (1) {
scanf("%d", &elem); // 输入数据
if (elem == 0) break; // 输入0时结束
if (*L == NULL) { // 表是空的时候
*L = (LinkList)malloc(sizeof(Node)); // 创建表头
if (*L == NULL) return ERROR; // 没创建出来报错
(*L)->data = elem; // 存入数据
tail = *L; // 尾节点，方便后续添加
} else { // 表不为空
tail->next = (LinkList)malloc(sizeof(Node)); // 创建新节点
if (!tail->next) return ERROR; // 没创建出来报错
tail->next->data = elem; // 存入数据
tail->next->prior = tail;
tail = tail->next; // 之前的尾节点指向新节点
}
}
tail->next = *L; // 形成环
(*L)->prior = tail;
return OK;
}
2.1 正向遍历
Status ListTraverse(LinkList L)
{
LinkList p = L; // 从自己开始
do {
printf("%d ",p->data);
p = p->next;
} while (p != L); // 到自己的时候停止
printf("\n");
return OK;
}
2.2反向遍历
Status ListTraverseBackwards(LinkList L)
{
LinkList p = L->prior;
do {
printf("%d ",p->data);
p = p->prior;
} while (p != L->prior);
printf("\n");
return OK;
}
2.3插入
插入.png
插入时，不管是单向还是双向，都需要先找对应位置的前驱。
Status ListInsert(LinkList *L, int loc, ElemType elem)
{
if (*L == NULL || loc < 1) return ERROR; // 空表，位置非法
LinkList tmp = (LinkList)malloc(sizeof(Node)); // 创建新节点
if (!tmp) return ERROR; // 没创建出来报错
tmp->data = elem; // 存入数据
LinkList target = *L; // 不管loc是多少，都是从头开始找
if (loc == 1) {
for (; target->next != *L; target = target->next); // 找到头结点的前一个节点(尾节点)
*L = tmp; // 头结点变为新节点
} else {
int idx = 1;
for (; target->next != *L && idx < loc - 1; target = target->next, ++idx); // 找到loc结点的前一个节点
if (target->next == *L || idx > loc - 1) return ERROR; // 找了一圈了，还没到指定位置，越界
}
tmp->next = target->next; // 新节点的后驱指向前一个节点的后驱
target->next = tmp; // 前一个节点指向新节点
tmp->next->prior = tmp; // 新节点后继的前驱指向新节点
tmp->prior = target; // 新节点的前驱指向前一个节点
return OK;
}
2.4 删除
image.png
删除时，由于双向链表可以访问前驱和后继，就不需要先找对应位置的前驱。
Status ListDeleteLoc(LinkList *L, int loc, ElemType *elem)
{
if (*L == NULL || loc < 1) return ERROR; // 空表，位置非法
LinkList target = *L; // 不管loc是多少，都是从头开始找
if (loc == 1) {
if ((*L)->next == *L) { // 如果只有1个节点
free(*L);
*L = NULL;
return OK;
};
*L = (*L)->next; // 头节点变为尾节点的下一个节点
} else {
int idx = 1;
for (; target->next != *L && idx < loc; target = target->next, ++idx); // 找到loc节点
if (target->next == *L || idx > loc) return ERROR; // 找了一圈了，还没到指定位置，越界
}
target->prior->next = target->next; // target的前驱指向target的后继
target->next->prior = target->prior; // 将target的后继的前驱指向target的前驱
*elem = target->data;
free(target); // 释放被删除节点
return OK;
}
2.5 删除指定元素
Status ListDeleteElem(LinkList *L, ElemType elem)
{
if (*L == NULL) return ERROR; // 空表
LinkList target = *L; // 都是从头开始找
for (; target->next != *L && target->data != elem; target = target->next); // 找到elem元素所在节点
if (target->next == *L && target->data != elem) return ERROR; // 找了一圈了，没有找到
if (target->next == target->prior) { // 前驱和后继相等，说明只有一个节点
free(target);
*L = NULL;
return OK;
}
target->prior->next = target->next; // target的前驱指向target的后继
target->next->prior = target->prior; // 将target的后继的前驱指向target的前驱
if (*L == target) *L = (*L)->next; // 如果是头节点，移动为下一个
free(target); // 释放被删除节点
return OK;
}
