数据结构基础--双向链表

双向链表概念

双向链表也叫双链表是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

双向链表每个节点的结构如下图所示, prior指向节点的前驱，next指向节点后继，

双链表结点

双向链表的创建一般有两种方式，一种是添加头结点的,一种是不添加头结点的，而添加头结点的方式，在首元结点的位置进行节点的删除和插入操作会比较方便，所以以下内容均在具有头结点的前提下进行的。

方便代码习惯一般先定义一些宏

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

创建一个双向链表，首先要先创建一个头结点，并且将头结点的将头结点的前驱和后继都指向空，data=-1只是自己定义的一种为空的方式，代码如下

Status CreateTwoLinkedList(LinkList *L){
    //创建一个头结点
    *L= (LinkList)malloc(sizeof(Node));
    //将头结点的前驱和后继都指向空
    (*L)->prior = NULL;
    (*L)->next = NULL;
   //data=-1
    (*L)->data = -1;
    return OK;
}

空链表赋值（尾插法）

Status EmptyLinkedListValue(LinkList *L){
    LinkList p = *L;
    //为了操作方便先增加一些数据
    for (int i = 0; i < 10; i++) {
        LinkList temp = (LinkList)malloc(sizeof(Node));
        temp->prior=NULL;
        temp->next=NULL;
        temp->data = i;
//为新增的结点建立双向链表的关系
//p的后继结点为temp
        p->next = temp;
//temp的前驱结点为p
        temp->prior = p;
//记录最后一个插入的结点位置，为了方便下次插入
        p = temp;
        
    }
    return OK;
}

打印双向链表

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

双向链表的插入

• 先判断插入的位置是否符合要求，如果插入的位置不满足条件，我们直接返回一个ERROR
• 如果插入的位置合法则插入新节点,首先要创建一个新节点
• 将p指向头结点
• 找到要插入的前一个位置
• 如果插入的位置超过链表本身的长度
• 判断插入位置是否为链表尾部，否则正常插入

我们按照上面的流程进行操作

Status LinkListInsert(LinkList *L, int i,ElemType data){
    //先判断插入的位置是否符合要求，如果插入的位置不满足条件，我们直接返回一个ERROR
    if(i < 1)return ERROR;
    //如果插入的位置合法则插入新节点
    //首先要创建一个新节点
    LinkList temp = (LinkList)malloc(sizeof(Node));
    temp->prior = NULL;
    temp->next = NULL;
    temp->data = data;
    //将p指向头结点
    LinkList p = *L;
    //找到要插入的前一个位置
    for (int j = 1; j < i; i++) {
        p = p->next;
        
    }
    // 如果插入的位置超过链表本身的长度
    if(p == NULL){
        return  ERROR;
    }
    // 判断插入位置是否为链表尾部;
    if (p->next == NULL) {
        p->next = temp;
        temp->prior = p;
    }else{
        p->next->prior = temp;
        temp->next = p ->next;
        temp->prior = p;
        p->next = temp;
        
    }
    return OK;
}

删除双向链表的指定位置上的节点

• 判断删除的位置是否合法，合法情况下继续，否则直接返回ERROR
• 判断k是否大于i,或者p为空返回ERROR
• 找到删除位置的前一个结点
• 创建临时指针delTemp 指向要删除的结点,并将要删除的结点的data 赋值给*e,带回到调用函数
• 将删除结点的前一个节点的next指向删除结点的后继，删除结点后继的前驱指向删除结点的前驱
• 将删除结点空间进行free

Status LinkListDelete(LinkList *L, int i, ElemType *e){
    //判断链表是否为空
    if (*L == NULL) {
        return ERROR;
    }
    int k = 1;
    LinkList p =(*L);
    //找到删除位置的前一个结点
    while (p != NULL && k < i) {
        p = p->next;
        k++;
    }
    //判断k是否大于i,或者p为空返回ERROR
    if (k>i || p == NULL) {
        return  ERROR;
    }
    //创建临时指针delTemp 指向要删除的结点,并将要删除的结点的data 赋值给*e,带回到调用函数
    LinkList delTemp =  p ->next;
    *e = delTemp->data;
   //删除节点的前驱的后继指向删除节点的后继
    p->next = delTemp->next;
   //删除节点的后继的前驱指向删除结点的前一个结点
    delTemp->next->prior = p;
   //将删除结点的空间进行释放
    free(delTemp);
    return OK;
}

删除双向链表指定的元素

• 遍历双向循环链表
• 判断当前结点的数据域和data是否相等,若相等则删除该结点
• 修改被删除结点的前驱结点的后继指针：将删除节点的前驱的后继指向删除结点的后继
• 修改被删除结点的后继结点的前驱指针：将删除节点的后继结点前驱指向删除结点的前驱
• 释放被删除结点p,退出循环

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

在双向链表中查找元素

• 循环找到要查找的元素
• 如果结果不是-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;
}

双向链表更新元素

先找到更新位置的结点，直接赋值即可

Status replaceLinkList(LinkList *L,int index,ElemType newElem){
    LinkList p = (*L)->next;
    
    for (int i = 1; i < index; i++) {
        p = p->next;
    }
    
    p->data = newElem;
    return OK;
}

总结：以上内容只是双向链表的简单使用，如有判断条件不全面的情况，可以自己添加。如有问题请联系QQ:983217036