1.1 双向链表简介
我们在单链表中，有了next指针，这就使得我们要查找下一个结点的时间复杂度为O(1)。可是如果我们要查找上一个结点的话，那最坏的时间复杂度就是O(n)了，因为每次都需要从头开始遍历查找。为了克服这一缺点，设计出双向链表。双向链表是在单链表的每个结点中，再设置一个指向前驱结点的指针域。所以在双向链表中的所有结点都有两个指针域，一个指向直接后继，一个指向直接前驱。
来看一下双向链表的结点构造：既有前驱指针域，也有后继指针域
这个前驱指针域和后继指针域，在双向链表中表现如下：
-
对于双向链表的第一个结点（头结点/首元结点），指向前驱结点的指针域为null，后面结点的前驱指针域都指向前驱结点，后继指针域指向后继结点。
-
尾结点没有后继，所以尾节点的后继指针域置null
在搞明白双向链表的前驱指针域和后继指针域之后，我们就可以开始构建及实现双向链表，主要注意在对链表的初始化、增、删、改、查等操作时这个前驱指针域和后继指针域的处理。
1.2 双向链表的实现
算法实现：
#include <stdio.h>
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */
//定义结点
typedef struct Node{
ElemType data;
struct Node *prior;
struct Node *next;
}Node;
typedef struct Node * LinkList;
//5.1 创建双向链接
Status createLinkList(LinkList *L){
//*L 指向头结点
*L = (LinkList)malloc(sizeof(Node));
if (*L == NULL) return ERROR;
(*L)->prior = NULL;
(*L)->next = NULL;
(*L)->data = -1;
//新增数据
LinkList p = *L;
for(int i=0; i < 10;i++){
//1.创建1个临时的结点
LinkList temp = (LinkList)malloc(sizeof(Node));
temp->prior = NULL;
temp->next = NULL;
temp->data = i;
//2.为新增的结点建立双向链表关系
//① temp 是p的后继
p->next = temp;
//② temp 的前驱是p
temp->prior = p;
//③ p 要记录最后的结点的位置,方便下一次插入
p = p->next;
}
return OK;
}
//5.2 打印循环链表的元素
void display(LinkList L){
LinkList temp = L->next;
if(temp == NULL){
printf("打印的双向链表为空!\n");
return;
}
while (temp) {
printf("%d ",temp->data);
temp = temp->next;
}
printf("\n");
}
//5.6.1 在双向链表中查找元素
int selectElem(LinkList L,ElemType elem){
LinkList p = L->next;
int i = 1;
while (p) {
if (p->data == elem) {
return i;
}
i++;
p = p->next;
}
return -1;
}
//5.6.2 在双向链表中更新结点
Status replaceLinkList(LinkList *L,int index,ElemType newElem){
LinkList p = (*L)->next;
for (int i = 1; i < index; i++) {
p = p->next;
if (p == NULL) {
printf("更新的结点超出链表的长度，请重新输入\n");
}
}
p->data = newElem;
return OK;
}
main函数调用：
int main(int argc, const char * argv[]) {
// insert code here...
printf("Hello, World!\n");
Status iStatus = 0;
LinkList L;
int temp,item;
iStatus = createLinkList(&L);
printf("iStatus = %d\n",iStatus);
printf("链表创建成功,打印链表:\n");
display(L);
printf("请输入你要查找的内容\n");
scanf("%d",&temp);
ElemType index = selectElem(L, temp);
printf("在双向链表中查找到数据域为%d的结点,位置是:%d\n",temp,index);
printf("请输入你要更新的结点以及内容，以空格隔开\n");
scanf("%d %d",&temp,&item);
iStatus = replaceLinkList(&L, temp, item);
printf("更新结点数据后的双向链表:\n");
display(L);
return 0;
}
打印结果：
Hello, World!
iStatus = 1
链表创建成功,打印链表:
0 1 2 3 4 5 6 7 8 9
请输入你要查找的内容
8
在双向链表中查找到数据域为8的结点,位置是:9
请输入你要更新的结点以及内容，以空格隔开
6 66
更新结点数据后的双向链表:
0 1 2 3 4 66 6 7 8 9
Program ended with exit code: 0
1.2.1 双向链表的插入
双向链表的插入重点说明一下，看图：
- 先找到要插入结点的前一个结点p
- 创建要插入的结点temp，并给数据域赋值、前后指针域置null
- 这里先做上图1、2步骤（以防止原始链表p->next结点丢失），1、2步骤可以不分先后，按图中步骤先p->next->prior = temp，然后temp->next = p->next
- 在做上图3、4步骤，3、4步骤可以不分先后，按图中步骤先temp->prior = p，然后p->next = temp; 即完成双向链表的插入。
- 当然这里的1、2、3、4步骤也不是绝对的，比如：4、2、3、1也可，但记住一点，一定要提前把p-next指针域先设置好，防止其丢失
- 最后特别说明一下：在做插入前先判断是否插入在尾节点，尾节点只用考虑上图3、4步骤即可
算法实现：
//5.3 双向链表插入元素
Status ListInsert(LinkList *L, int i, ElemType data){
//1. 插入的位置不合法 为0或者为负数
if(i < 1) return ERROR;
//2. 新建结点
LinkList temp = (LinkList)malloc(sizeof(Node));
temp->data = data;
temp->prior = NULL;
temp->next = NULL;
//3.将p指向头结点!
LinkList p = *L;
//4. 找到插入位置i直接的结点
for(int j = 1; j < i && p;j++)
p = p->next;
//5. 如果插入的位置超过链表本身的长度
if(p == NULL){
return ERROR;
}
//6. 判断插入位置是否为链表尾部;
if (p->next == NULL) {
p->next = temp;
temp->prior = p;
}else
{
//1️⃣ 将p->next 结点的前驱prior = temp
p->next->prior = temp;
//2️⃣ 将temp->next 指向原来的p->next
temp->next = p->next;
//3️⃣ p->next 更新成新创建的temp
p->next = temp;
//4️⃣ 新创建的temp前驱 = p
temp->prior = p;
}
return OK;
}
main函数调用：
int main(int argc, const char * argv[]) {
// insert code here...
printf("Hello, World!\n");
Status iStatus = 0;
LinkList L;
int temp,item;
iStatus = createLinkList(&L);
printf("iStatus = %d\n",iStatus);
printf("链表创建成功,打印链表:\n");
display(L);
printf("请输入插入的位置和数据，以空格隔开\n");
scanf("%d %d",&temp,&item);
iStatus = ListInsert(&L, temp, item);
printf("插入数据,打印链表:\n");
display(L);
return 0;
}
打印结果：
Hello, World!
iStatus = 1
链表创建成功,打印链表:
0 1 2 3 4 5 6 7 8 9
请输入插入的位置和数据，以空格隔开
4 78
插入数据,打印链表:
0 1 2 78 3 4 5 6 7 8 9
Program ended with exit code: 0
1.2.2 双向链表的删除
双向链表的删除，这里也说明一下，看图：
- 先找到要删除结点的前一个结点p
- 创建要插入的结点delTemp，并给数据域赋值、前后指针域赋空值
- 将前一结点p的后继，指向delTemp的后继p->next = delTemp->next
- 这里有些特殊，要先判断一下待删除的结点delTemp（如果是尾节点没有后继），是否有后继，有后继的话delTemp->next->prior = p，没有后继结点就不需要
- 最后释放要删除的结点delTemp
算法实现：
//5.4 删除双向链表指定位置上的结点
Status ListDelete(LinkList *L, int i, ElemType *e){
int k = 1;
LinkList p = (*L);
//1.判断双向链表是否为空,如果为空则返回ERROR;
if (*L == NULL) {
return ERROR;
}
//2. 将指针p移动到删除元素位置前一个
while (k < i && p != NULL) {
p = p->next;
k++;
}
//3.如果k>i 或者 p == NULL 则返回ERROR
if (k>i || p == NULL) {
return ERROR;
}
//4.创建临时指针delTemp 指向要删除的结点,并将要删除的结点的data 赋值给*e,带回到main函数
LinkList delTemp = p->next;
*e = delTemp->data;
//5. p->next 等于要删除的结点的下一个结点
p->next = delTemp->next;
//6. 如果删除结点的下一个结点不为空,则将将要删除的下一个结点的前驱指针赋值p;
if (delTemp->next != NULL) {
delTemp->next->prior = p;
}
//7.删除delTemp结点
free(delTemp);
return OK;
}
main函数调用：
int main(int argc, const char * argv[]) {
// insert code here...
printf("Hello, World!\n");
Status iStatus = 0;
LinkList L;
int temp,e;
iStatus = createLinkList(&L);
printf("iStatus = %d\n",iStatus);
printf("链表创建成功,打印链表:\n");
display(L);
printf("请输入删除的位置\n");
scanf("%d",&temp);
iStatus = ListDelete(&L, temp, &e);
printf("删除元素: 删除位置为%d,data = %d\n",temp,e);
printf("删除操作之后的,双向链表:\n");
display(L);
return 0;
}
打印结果：
Hello, World!
iStatus = 1
链表创建成功,打印链表:
0 1 2 3 4 5 6 7 8 9
请输入删除的位置
5
删除元素: 删除位置为5,data = 4
删除操作之后的,双向链表:
0 1 2 3 5 6 7 8 9
Program ended with exit code: 0
- 删除指定的元素
这个比较简单，通过要删除的元素和每个结点的data比较，找到要删除结点delTemp，参照上图1、2步骤操作，最后释放要删除的结点。
算法实现：
//5.5 删除双向链表指定的元素
Status LinkListDeletVAL(LinkList *L, int data){
LinkList delTemp = *L;
//1.遍历双向循环链表
while (delTemp) {
//2.判断当前结点的数据域和data是否相等,若相等则删除该结点
if (delTemp->data == data) {
//修改被删除结点的前驱结点的后继指针,参考图上步骤1️⃣
delTemp->prior->next = delTemp->next;
//修改被删除结点的后继结点的前驱指针,参考图上步骤2️⃣
if(delTemp->next != NULL){
delTemp->next->prior = delTemp->prior;
}
//释放被删除结点p
free(delTemp);
//退出循环
break;
}
//没有找到该结点,则继续移动指针p
delTemp = delTemp->next;
}
return OK;
}
main函数调用：
int main(int argc, const char * argv[]) {
// insert code here...
printf("Hello, World!\n");
Status iStatus = 0;
LinkList L;
int temp;
iStatus = createLinkList(&L);
printf("iStatus = %d\n",iStatus);
printf("链表创建成功,打印链表:\n");
display(L);
printf("请输入你要删除的内容\n");
scanf("%d",&temp);
iStatus = LinkListDeletVAL(&L, temp);
printf("删除指定data域等于%d的结点,双向链表:\n",temp);
display(L);
return 0;
}
打印结果：
Hello, World!
iStatus = 1
链表创建成功,打印链表:
0 1 2 3 4 5 6 7 8 9
请输入你要删除的内容
8
删除指定data域等于8的结点,双向链表:
0 1 2 3 4 5 6 7 9
Program ended with exit code: 0
