线性表->链式存储->双向链表

文字描述

　　之前的链表(单链表、循环链表)的链式存储结构中只有一个指示直接后继的指针域。由此，从某个结点出发只能顺指针往后寻查其他结点。若要寻查结点的直接前驱，则需从表头指针出发。即单链表中，NextElem的执行时间为1，而PriorElem的执行时间为n。为了克服单链表这种缺点，可利用双向链表。

　　在双向链表中，每个节点有两个指针域，一个指向其直接后继，一个指向其直接前驱。

示意图

算法分析

插入、删除、查找、求后继等同单链表。但是求前驱不一样，其时间复杂度为1。

代码实现

//
// Created by lady on 19-1-31.
//

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

//线性表的双向循环链表存储结构
typedef struct ElemType{
    char data[10];
}ElemType;
typedef struct DuLNode{
    ElemType e;
    struct DuLNode *prior;
    struct DuLNode *next;
}DuLNode, *DuLinkList;

//构造一个空的双向循环链表
static int InitList_DuL(DuLinkList *L)
{
    (*L) = (DuLinkList)malloc(sizeof(DuLNode));
    (*L)->prior = (*L);
    (*L)->next = (*L);
    memset((*L)->e.data, 0, sizeof((*L)->e.data));
    return 0;
}

//销毁L
static int Destory_DuL(DuLinkList *L)
{
    DuLNode *p = NULL;
    DuLNode *q = NULL;
    p = (*L)->next;
    while(p){
        q = p;
        p = p->next;
        free(q);
        if(p == (*L))
            break;
    }
    free(*L);
    (*L) = NULL;
    return 0;
}

//返回双向链表L中的第i个位置的元素
static DuLNode *GetElemP_DuL(DuLinkList *L, int i)
{
    if(L == NULL){
        return NULL;
    }
    DuLNode *p = (*L)->next;
    int index = 1;
    while(index<i && p){
        index += 1;
        p = p->next;
    }
    if(index == i && p){
        return p;
    }else{
        return NULL;
    }
}

//在L的指定位置i的元素前面插入元素e
static int ListInsert_DuL(DuLinkList *L, int i, ElemType e)
{
    DuLNode *p = NULL;
    DuLNode *new = NULL;
    if((p=GetElemP_DuL(L, i)) == NULL){
        return -1;
    }
    if((new = (DuLNode*)malloc(sizeof(DuLNode))) == NULL){
        return -1;
    }
    new->e = e;
    new->prior = p->prior;
    p->prior->next = new;
    new->next = p;
    p->prior = new;
    return 0;
}

//删除L中的第loc个数据元素，并将被删元素的值存放在e中
static int ListDelete_DuL(DuLinkList *L, int i, ElemType *e)
{
    DuLNode *p = NULL;
    if((p=GetElemP_DuL(L, i)) == NULL){
        return -1;
    }
    (*e) = p->e;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    return 0;
}

//依次对L的每个数据元素调用函数fun
static int listTraverse_DuL(DuLinkList *L, int (*fun)(ElemType,int), char note[])
{
    printf("遍历双向循环链表%s:", note);
    DuLNode *p = NULL;
    p = (*L)->next;
    int i = 1;
    while(p){
        fun(p->e, i);
        i+=1;
        p = p->next;
        if(p == (*L))
            break;
    }
    printf("
");
    return 0;
}

static int print(ElemType e, int loc)
{
    printf("%3d=%-10s", loc, e.data);
}

//创建一个长度为n的双向链表
static int CreateList_DuL(DuLinkList *L, int n, char note[])
{
    printf("创建一个长度为%d的双向循环链表%s!
", n, note);
    InitList_DuL(L);
    ElemType e;
    int i = 0;
    for(i=0; i<n; i++){
        printf("输入第%d个元素:", i+1);
        scanf("%s[^\n]", e.data);
        ListInsert_DuL(L, i+1, e);
    }
    return 0;
}

int main(int argc, char *argv[])
{
    ElemType e;
    DuLinkList L;
    int location=0;

    CreateList_DuL(&L, 5, "L");

    listTraverse_DuL(&L, print, "L");


    printf("输入插入元素的位置:");
    scanf("%d", &location);
    printf("输入插入元素的数据:");
    scanf("%s[^\n]", e.data);
    ListInsert_DuL(&L, location, e);
    listTraverse_DuL(&L, print, "L");

    printf("输入删除元素的位置:");
    scanf("%d", &location);
    ListDelete_DuL(&L, location, &e);

    printf("位于%d的元素%s已经从双向循环链表中被删除！
", location, e.data);
    listTraverse_DuL(&L, print, "L");

    Destory_DuL(&L);
    printf("双向链表已经被销毁!
");
    return 0;
}

代码运行

/home/lady/CLionProjects/untitled/cmake-build-debug/untitled
创建一个长度为5的双向循环链表L!
输入第1个元素:c
输入第2个元素:b
输入第3个元素:e
输入第4个元素:g
输入第5个元素:f
遍历双向循环链表L:  1=c           2=b           3=e           4=g           5=f         
输入插入元素的位置:3
输入插入元素的数据:test
遍历双向循环链表L:  1=c           2=b           3=test        4=e           5=g           6=f         
输入删除元素的位置:4
位于4的元素e已经从双向循环链表中被删除！
遍历双向循环链表L:  1=c           2=b           3=test        4=g           5=f         
双向链表已经被销毁!

Process finished with exit code 0