1.双向链表

1.1定义

单向链表中各结点中都只包含一个指针next，且都统一指向直接后继结点。 双向链表是在单向链表的基础上添加了前驱指针prior。

结点的结构定义如下：

//定义结点
typedef struct Node{
    ElemType data;       //用于存储数据元素
    struct Node *prior;  //用于指向当前节点的直接前驱节点；
    struct Node *next;   //用于指向当前节点的直接后继节点
}Node;

双向链表的结构

双向链表可以带头结点也可以不带头结点，当然带头结点的双向链表更好操作，插入和删除时不需要单独处理首元结点。

1.2创建

下面我们创建一个带头结点的双向链表。

Status createLinkList(LinkList *L){
    //*L 指向头结点
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) return ERROR;
    
    //头结点数据初始化
    (*L)->prior = NULL;
    (*L)->next = NULL;
    (*L)->data = -1;
    
    return OK;
}

1.3插入

假设我们要在A和B的中间位置插入数据，那么需要以下几个步骤：
a. 创建要插入的结点D b. 找到A c. 将A的next(也就是B结点)的prior指向D d. 将D的next指向B e. 将A的next指向D f. 将D的prior指向A 这样就断开了A与B之间的链接,建立起了B与D, A与D的链接。如下图所示

注意，还需要考虑一种特殊情况，就是插入的尾结点C之后时，由于C的尾结点的next为null. 所以c、d步骤可以省略了。代码实现如下：

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
    {
        // 将p->next 结点的前驱prior = temp
        p->next->prior = temp;
        // 将temp->next 指向原来的p->next
        temp->next = p->next;
        // p->next 更新成新创建的temp
        p->next = temp;
        // 新创建的temp前驱 = p
        temp->prior = p;
    }
    
    return  OK;
}

1.4删除

根据索引删除节点时，只需遍历链表找到要删除的结点的前一个，更改前驱节点的next和后继节点的prior即可。

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;
    
}

根据值删除节点时，只需遍历链表找到要删除的结点，更改前驱节点的next和后继节点的prior即可。

//删除双向链表指定的元素
Status LinkListDeletVAL(LinkList *L, int data){
    
    LinkList p = *L;
    
    //1.遍历双向循环链表
    while (p) {
       
        //2.判断当前结点的数据域和data是否相等,若相等则删除该结点
        if (p->data == data) {
            
            //修改被删除结点的前驱结点的后继指针,参考图上步骤1️⃣
            p->prior->next = p->next;
            //修改被删除结点的后继结点的前驱指针,参考图上步骤2️⃣
            if(p->next != NULL){
                p->next->prior = p->prior;
            }
            //释放被删除结点p
            free(p);
            //退出循环
            break;
        }
        
        //没有找到该结点,则继续移动指针p
        p = p->next;
    }
    
    return OK;
    
}

2.双向循环链表

双向循环链表，与双向链表相比尾结点的next不在为空，而是指向了头结点，形成了一个闭环。双向循环链表的结点结构与双向链表的结构完全相同。

2.1创建

代码如下

Status creatLinkList(LinkList *L){
    
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) {
        return ERROR;
    }
    
    (*L)->next = (*L);
    (*L)->prior = (*L);
    (*L)->data = -1;
    
    return OK;
}

2.2插入

双向循环链表的插入过程与双向链表的插入个过程一模一样。

Status LinkListInsert(LinkList *L, int index, ElemType e){
   
    //1. 创建指针p,指向双向链表头
    LinkList p = (*L);
    int i = 1;
    
    //2.双向循环链表为空,则返回error
    if(*L == NULL) return ERROR;
   
    //3.找到插入前一个位置上的结点p
    while (i < index && p->next != *L) {
        p = p->next;
        i++;
    }
    
    //4.如果i>index 则返回error
    if (i > index)  return ERROR;
    
    //5.创建新结点temp
    LinkList temp = (LinkList)malloc(sizeof(Node));
    
    //6.temp 结点为空,则返回error
    if (temp == NULL) return ERROR;
    
    //7.将生成的新结点temp数据域赋值e.
    temp->data = e;
    
    //8.将结点temp 的前驱结点为p;
    temp->prior = p;
    
    //9.temp的后继结点指向p->next;
    temp->next = p->next;
    
    //10.p的后继结点的前驱为temp;
    p->next->prior = temp;
    
    //11.新结点temp成为p的新的后继结点;
    p->next = temp;
    
    return OK;
}

2.3删除

Status LinkListDelete(LinkList *L,int index,ElemType *e){
    
    int i = 1;
    LinkList temp = (*L)->next;
    
    if (*L == NULL) {
        return  ERROR;
    }
    
    //如果删除到只剩下首元结点了,则直接将*L置空;
    if(temp->next == *L){
        free(*L);
        (*L) = NULL;
        return OK;
    }
    
    //1.找到要删除的结点
    while (i < index) {
        temp = temp->next;
        i++;
    }

    //2.给e赋值要删除结点的数据域
    *e = temp->data;
    
    //3.修改被删除结点的前驱结点的后继指针 
    temp->prior->next = temp->next;
    //4.修改被删除结点的后继结点的前驱指针
    temp->next->prior = temp->prior;
    
    //5. 释放结点temp
    free(temp);
    
    return OK;
    
}

数据结构与算法——双向链表